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-2022 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  */
68 SCIP_EXPORT
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  */
91 SCIP_EXPORT
92 int SCIPgetNReoptRuns(
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  */
114 SCIP_EXPORT
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  */
138 SCIP_EXPORT
139 SCIP_Longint SCIPgetNNodes(
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  */
161 SCIP_EXPORT
162 SCIP_Longint SCIPgetNTotalNodes(
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  */
184 SCIP_EXPORT
185 SCIP_Longint SCIPgetNFeasibleLeaves(
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  */
207 SCIP_EXPORT
208 SCIP_Longint SCIPgetNInfeasibleLeaves(
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  */
230 SCIP_EXPORT
231 SCIP_Longint SCIPgetNObjlimLeaves(
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  */
253 SCIP_EXPORT
254 int SCIPgetNRootboundChgs(
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  */
276 SCIP_EXPORT
277 int SCIPgetNRootboundChgsRun(
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  */
299 SCIP_EXPORT
300 SCIP_Longint SCIPgetNDelayedCutoffs(
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  */
322 SCIP_EXPORT
323 SCIP_Longint SCIPgetNLPs(
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  */
337 SCIP_EXPORT
338 SCIP_Longint SCIPgetNLPIterations(
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  */
359 SCIP_EXPORT
360 SCIP_Longint SCIPgetNNZs(
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  */
374 SCIP_EXPORT
375 SCIP_Longint SCIPgetNRootLPIterations(
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  */
389 SCIP_EXPORT
390 SCIP_Longint SCIPgetNRootFirstLPIterations(
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  */
403 SCIP_EXPORT
404 SCIP_Longint SCIPgetNPrimalLPs(
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  */
417 SCIP_EXPORT
418 SCIP_Longint SCIPgetNPrimalLPIterations(
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  */
431 SCIP_EXPORT
432 SCIP_Longint SCIPgetNDualLPs(
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  */
445 SCIP_EXPORT
446 SCIP_Longint SCIPgetNDualLPIterations(
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  */
459 SCIP_EXPORT
460 SCIP_Longint SCIPgetNBarrierLPs(
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  */
473 SCIP_EXPORT
474 SCIP_Longint SCIPgetNBarrierLPIterations(
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  */
487 SCIP_EXPORT
488 SCIP_Longint SCIPgetNResolveLPs(
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  */
503 SCIP_EXPORT
504 SCIP_Longint SCIPgetNResolveLPIterations(
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  */
517 SCIP_EXPORT
518 SCIP_Longint SCIPgetNPrimalResolveLPs(
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  */
533 SCIP_EXPORT
534 SCIP_Longint SCIPgetNPrimalResolveLPIterations(
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  */
547 SCIP_EXPORT
548 SCIP_Longint SCIPgetNDualResolveLPs(
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  */
563 SCIP_EXPORT
564 SCIP_Longint SCIPgetNDualResolveLPIterations(
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  */
577 SCIP_EXPORT
578 SCIP_Longint SCIPgetNNodeLPs(
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  */
591 SCIP_EXPORT
592 SCIP_Longint SCIPgetNNodeZeroIterationLPs(
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  */
605 SCIP_EXPORT
606 SCIP_Longint SCIPgetNNodeLPIterations(
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  */
619 SCIP_EXPORT
620 SCIP_Longint SCIPgetNNodeInitLPs(
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  */
633 SCIP_EXPORT
634 SCIP_Longint SCIPgetNNodeInitLPIterations(
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  */
647 SCIP_EXPORT
648 SCIP_Longint SCIPgetNDivingLPs(
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  */
661 SCIP_EXPORT
662 SCIP_Longint SCIPgetNDivingLPIterations(
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  */
675 SCIP_EXPORT
676 SCIP_Longint SCIPgetNStrongbranchs(
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  */
689 SCIP_EXPORT
690 SCIP_Longint SCIPgetNStrongbranchLPIterations(
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  */
703 SCIP_EXPORT
704 SCIP_Longint SCIPgetNRootStrongbranchs(
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  */
717 SCIP_EXPORT
718 SCIP_Longint SCIPgetNRootStrongbranchLPIterations(
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  */
729 SCIP_EXPORT
730 int SCIPgetNPriceRounds(
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  */
743 SCIP_EXPORT
744 int SCIPgetNPricevars(
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  */
757 SCIP_EXPORT
758 int SCIPgetNPricevarsFound(
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  */
771 SCIP_EXPORT
772 int SCIPgetNPricevarsApplied(
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  */
783 SCIP_EXPORT
784 int SCIPgetNSepaRounds(
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  */
797 SCIP_EXPORT
798 int SCIPgetNCutsFound(
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  */
811 SCIP_EXPORT
812 int SCIPgetNCutsFoundRound(
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  */
825 SCIP_EXPORT
826 int SCIPgetNCutsApplied(
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  */
845 SCIP_EXPORT
846 SCIP_Longint SCIPgetNConflictConssFound(
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  */
865 SCIP_EXPORT
866 int SCIPgetNConflictConssFoundNode(
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  */
885 SCIP_EXPORT
886 SCIP_Longint SCIPgetNConflictConssApplied(
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  */
905 SCIP_EXPORT
906 SCIP_Longint SCIPgetNConflictDualproofsApplied(
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  */
925 SCIP_EXPORT
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  */
945 SCIP_EXPORT
946 int SCIPgetMaxTotalDepth(
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  */
965 SCIP_EXPORT
966 SCIP_Longint SCIPgetNBacktracks(
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  */
981 SCIP_EXPORT
982 int SCIPgetNActiveConss(
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  */
994 SCIP_EXPORT
995 int SCIPgetNEnabledConss(
996  SCIP* scip /**< SCIP data structure */
997  );
998 
999 /** gets average dual bound of all unprocessed nodes for original problem */
1000 SCIP_EXPORT
1001 SCIP_Real SCIPgetAvgDualbound(
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  */
1014 SCIP_EXPORT
1015 SCIP_Real SCIPgetAvgLowerbound(
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  */
1033 SCIP_EXPORT
1034 SCIP_Real SCIPgetDualbound(
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  */
1052 SCIP_EXPORT
1053 SCIP_Real SCIPgetLowerbound(
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  */
1069 SCIP_EXPORT
1070 SCIP_Real SCIPgetDualboundRoot(
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  */
1086 SCIP_EXPORT
1087 SCIP_Real SCIPgetLowerboundRoot(
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  */
1103 SCIP_EXPORT
1104 SCIP_Real SCIPgetFirstLPDualboundRoot(
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  */
1120 SCIP_EXPORT
1121 SCIP_Real SCIPgetFirstLPLowerboundRoot(
1122  SCIP* scip /**< SCIP data structure */
1123  );
1124 
1125 
1126 /** the primal bound of the very first solution */
1127 SCIP_EXPORT
1128 SCIP_Real SCIPgetFirstPrimalBound(
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  */
1147 SCIP_EXPORT
1148 SCIP_Real SCIPgetPrimalbound(
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  */
1167 SCIP_EXPORT
1168 SCIP_Real SCIPgetUpperbound(
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  */
1190 SCIP_EXPORT
1191 SCIP_Real SCIPgetCutoffbound(
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  */
1213 SCIP_EXPORT
1214 SCIP_RETCODE SCIPupdateCutoffbound(
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  */
1235 SCIP_EXPORT
1236 SCIP_Bool SCIPisPrimalboundSol(
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  */
1251 SCIP_EXPORT
1252 SCIP_Real SCIPgetGap(
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  */
1267 SCIP_EXPORT
1268 SCIP_Real SCIPgetTransGap(
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  */
1287 SCIP_EXPORT
1288 SCIP_Longint SCIPgetNSolsFound(
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  */
1310 SCIP_EXPORT
1311 SCIP_Longint SCIPgetNLimSolsFound(
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  */
1330 SCIP_EXPORT
1331 SCIP_Longint SCIPgetNBestSolsFound(
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  */
1343 SCIP_EXPORT
1344 SCIP_Real SCIPgetAvgPseudocost(
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  */
1359 SCIP_EXPORT
1360 SCIP_Real SCIPgetAvgPseudocostCurrentRun(
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  */
1373 SCIP_EXPORT
1374 SCIP_Real SCIPgetAvgPseudocostCount(
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  */
1389 SCIP_EXPORT
1390 SCIP_Real SCIPgetAvgPseudocostCountCurrentRun(
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  */
1403 SCIP_EXPORT
1404 SCIP_Real SCIPgetPseudocostCount(
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  */
1418 SCIP_EXPORT
1419 SCIP_Real SCIPgetAvgPseudocostScore(
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  */
1431 SCIP_EXPORT
1432 SCIP_Real SCIPgetPseudocostVariance(
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  */
1448 SCIP_EXPORT
1449 SCIP_Real SCIPgetAvgPseudocostScoreCurrentRun(
1450  SCIP* scip /**< SCIP data structure */
1451  );
1452 
1453 /** gets the average conflict score value over all variables */
1454 SCIP_EXPORT
1455 SCIP_Real SCIPgetAvgConflictScore(
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  */
1467 SCIP_EXPORT
1468 SCIP_Real SCIPgetAvgConflictScoreCurrentRun(
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  */
1480 SCIP_EXPORT
1481 SCIP_Real SCIPgetAvgConflictlengthScore(
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  */
1495 SCIP_EXPORT
1496 SCIP_Real SCIPgetAvgConflictlengthScoreCurrentRun(
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  */
1508 SCIP_EXPORT
1509 SCIP_Real SCIPgetAvgInferences(
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  */
1524 SCIP_EXPORT
1525 SCIP_Real SCIPgetAvgInferencesCurrentRun(
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  */
1538 SCIP_EXPORT
1539 SCIP_Real SCIPgetAvgInferenceScore(
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  */
1553 SCIP_EXPORT
1554 SCIP_Real SCIPgetAvgInferenceScoreCurrentRun(
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  */
1566 SCIP_EXPORT
1567 SCIP_Real SCIPgetAvgCutoffs(
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  */
1582 SCIP_EXPORT
1583 SCIP_Real SCIPgetAvgCutoffsCurrentRun(
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  */
1596 SCIP_EXPORT
1597 SCIP_Real SCIPgetAvgCutoffScore(
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  */
1609 SCIP_EXPORT
1610 SCIP_Real SCIPgetAvgCutoffScoreCurrentRun(
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  */
1623 SCIP_EXPORT
1624 SCIP_Real SCIPgetDeterministicTime(
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  */
1647 SCIP_EXPORT
1648 SCIP_RETCODE SCIPprintOrigProblem(
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  */
1672 SCIP_EXPORT
1673 SCIP_RETCODE SCIPprintTransProblem(
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  */
1696 SCIP_EXPORT
1697 void SCIPprintStatusStatistics(
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  */
1714 SCIP_EXPORT
1715 void SCIPprintTimingStatistics(
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  */
1732 SCIP_EXPORT
1733 void SCIPprintOrigProblemStatistics(
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  */
1750 SCIP_EXPORT
1751 void SCIPprintTransProblemStatistics(
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  */
1767 SCIP_EXPORT
1768 void SCIPprintPresolverStatistics(
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  */
1784 SCIP_EXPORT
1785 void SCIPprintConstraintStatistics(
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  */
1801 SCIP_EXPORT
1802 void SCIPprintConstraintTimingStatistics(
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  */
1818 SCIP_EXPORT
1819 void SCIPprintPropagatorStatistics(
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  */
1835 SCIP_EXPORT
1836 void SCIPprintConflictStatistics(
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  */
1847 SCIP_EXPORT
1848 void SCIPprintSeparatorStatistics(
1849  SCIP* scip, /**< SCIP data structure */
1850  FILE* file /**< output file */
1851  );
1852 
1853 /** outputs cutselector 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  */
1859 SCIP_EXPORT
1860 void SCIPprintCutselectorStatistics(
1861  SCIP* scip, /**< SCIP data structure */
1862  FILE* file /**< output file */
1863  );
1864 
1865 /** outputs pricer 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  */
1871 SCIP_EXPORT
1872 void SCIPprintPricerStatistics(
1873  SCIP* scip, /**< SCIP data structure */
1874  FILE* file /**< output file */
1875  );
1876 
1877 /** outputs branching rule statistics
1878  *
1879  * @pre This method can be called if SCIP is in one of the following stages:
1880  * - \ref SCIP_STAGE_SOLVING
1881  * - \ref SCIP_STAGE_SOLVED
1882  */
1883 SCIP_EXPORT
1884 void SCIPprintBranchruleStatistics(
1885  SCIP* scip, /**< SCIP data structure */
1886  FILE* file /**< output file */
1887  );
1888 
1889 /** outputs heuristics statistics
1890  *
1891  * @pre This method can be called if SCIP is in one of the following stages:
1892  * - \ref SCIP_STAGE_PRESOLVING
1893  * - \ref SCIP_STAGE_EXITPRESOLVE
1894  * - \ref SCIP_STAGE_PRESOLVED
1895  * - \ref SCIP_STAGE_SOLVING
1896  * - \ref SCIP_STAGE_SOLVED
1897  */
1898 SCIP_EXPORT
1899 void SCIPprintHeuristicStatistics(
1900  SCIP* scip, /**< SCIP data structure */
1901  FILE* file /**< output file */
1902  );
1903 
1904 /** outputs compression statistics
1905  *
1906  * @pre This method can be called if SCIP is in one of the following stages:
1907  * - \ref SCIP_STAGE_PRESOLVING
1908  * - \ref SCIP_STAGE_EXITPRESOLVE
1909  * - \ref SCIP_STAGE_PRESOLVED
1910  * - \ref SCIP_STAGE_SOLVING
1911  * - \ref SCIP_STAGE_SOLVED
1912  */
1913 SCIP_EXPORT
1914 void SCIPprintCompressionStatistics(
1915  SCIP* scip, /**< SCIP data structure */
1916  FILE* file /**< output file */
1917  );
1918 
1919 /** outputs LP 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  */
1925 SCIP_EXPORT
1926 void SCIPprintLPStatistics(
1927  SCIP* scip, /**< SCIP data structure */
1928  FILE* file /**< output file */
1929  );
1930 
1931 /** outputs NLP 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  */
1937 SCIP_EXPORT
1938 void SCIPprintNLPStatistics(
1939  SCIP* scip, /**< SCIP data structure */
1940  FILE* file /**< output file */
1941  );
1942 
1943 /** outputs relaxator 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  */
1949 SCIP_EXPORT
1950 void SCIPprintRelaxatorStatistics(
1951  SCIP* scip, /**< SCIP data structure */
1952  FILE* file /**< output file */
1953  );
1954 
1955 /** outputs tree 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  */
1961 SCIP_EXPORT
1962 void SCIPprintTreeStatistics(
1963  SCIP* scip, /**< SCIP data structure */
1964  FILE* file /**< output file */
1965  );
1966 
1967 /** outputs root statistics
1968  *
1969  * @pre This method can be called if SCIP is in one of the following stages:
1970  * - \ref SCIP_STAGE_SOLVING
1971  * - \ref SCIP_STAGE_SOLVED
1972  */
1973 SCIP_EXPORT
1974 void SCIPprintRootStatistics(
1975  SCIP* scip, /**< SCIP data structure */
1976  FILE* file /**< output file */
1977  );
1978 
1979 /** outputs solution statistics
1980  *
1981  * @pre This method can be called if SCIP is in one of the following stages:
1982  * - \ref SCIP_STAGE_PRESOLVING
1983  * - \ref SCIP_STAGE_EXITPRESOLVE
1984  * - \ref SCIP_STAGE_PRESOLVED
1985  * - \ref SCIP_STAGE_SOLVING
1986  * - \ref SCIP_STAGE_SOLVED
1987  */
1988 SCIP_EXPORT
1989 void SCIPprintSolutionStatistics(
1990  SCIP* scip, /**< SCIP data structure */
1991  FILE* file /**< output file */
1992  );
1993 
1994 /** outputs concurrent solver statistics
1995  *
1996  * @pre This method can be called if SCIP is in one of the following stages:
1997  * - \ref SCIP_STAGE_TRANSFORMED
1998  * - \ref SCIP_STAGE_INITPRESOLVE
1999  * - \ref SCIP_STAGE_PRESOLVING
2000  * - \ref SCIP_STAGE_EXITPRESOLVE
2001  * - \ref SCIP_STAGE_PRESOLVED
2002  * - \ref SCIP_STAGE_SOLVING
2003  * - \ref SCIP_STAGE_SOLVED
2004  */
2005 SCIP_EXPORT
2006 void SCIPprintConcsolverStatistics(
2007  SCIP* scip, /**< SCIP data structure */
2008  FILE* file /**< output file */
2009  );
2010 
2011 /** outputs Benders' decomposition statistics
2012  *
2013  * @pre This method can be called if SCIP is in one of the following stages:
2014  * - \ref SCIP_STAGE_SOLVING
2015  * - \ref SCIP_STAGE_SOLVED
2016  */
2017 SCIP_EXPORT
2018 void SCIPprintBendersStatistics(
2019  SCIP* scip, /**< SCIP data structure */
2020  FILE* file /**< output file */
2021  );
2022 
2023 /** outputs expression handler statistics
2024  *
2025  * @pre This method can be called if SCIP is in one of the following stages:
2026  * - \ref SCIP_STAGE_PROBLEM
2027  * - \ref SCIP_STAGE_TRANSFORMED
2028  * - \ref SCIP_STAGE_INITPRESOLVE
2029  * - \ref SCIP_STAGE_PRESOLVING
2030  * - \ref SCIP_STAGE_EXITPRESOLVE
2031  * - \ref SCIP_STAGE_PRESOLVED
2032  * - \ref SCIP_STAGE_SOLVING
2033  * - \ref SCIP_STAGE_SOLVED
2034  */
2035 SCIP_EXPORT
2036 void SCIPprintExpressionHandlerStatistics(
2037  SCIP* scip, /**< SCIP data structure */
2038  FILE* file /**< output file */
2039  );
2040 
2041 /** outputs NLPI statistics
2042  *
2043  * @pre This method can be called if SCIP is in one of the following stages:
2044  * - \ref SCIP_STAGE_PROBLEM
2045  * - \ref SCIP_STAGE_TRANSFORMED
2046  * - \ref SCIP_STAGE_INITPRESOLVE
2047  * - \ref SCIP_STAGE_PRESOLVING
2048  * - \ref SCIP_STAGE_EXITPRESOLVE
2049  * - \ref SCIP_STAGE_PRESOLVED
2050  * - \ref SCIP_STAGE_SOLVING
2051  * - \ref SCIP_STAGE_SOLVED
2052  */
2053 SCIP_EXPORT
2054 void SCIPprintNLPIStatistics(
2055  SCIP* scip, /**< SCIP data structure */
2056  FILE* file /**< output file */
2057  );
2058 
2059 /** outputs solving statistics
2060  *
2061  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2062  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2063  *
2064  * @note If limits have been changed between the solution and the call to this function, the status is recomputed and
2065  * thus may to correspond to the original status.
2066  *
2067  * @pre This method can be called if SCIP is in one of the following stages:
2068  * - \ref SCIP_STAGE_INIT
2069  * - \ref SCIP_STAGE_PROBLEM
2070  * - \ref SCIP_STAGE_TRANSFORMED
2071  * - \ref SCIP_STAGE_INITPRESOLVE
2072  * - \ref SCIP_STAGE_PRESOLVING
2073  * - \ref SCIP_STAGE_EXITPRESOLVE
2074  * - \ref SCIP_STAGE_PRESOLVED
2075  * - \ref SCIP_STAGE_SOLVING
2076  * - \ref SCIP_STAGE_SOLVED
2077  */
2078 SCIP_EXPORT
2079 SCIP_RETCODE SCIPprintStatistics(
2080  SCIP* scip, /**< SCIP data structure */
2081  FILE* file /**< output file (or NULL for standard output) */
2082  );
2083 
2084 /** outputs reoptimization statistics
2085  *
2086  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2087  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2088  *
2089  * @pre This method can be called if SCIP is in one of the following stages:
2090  * - \ref SCIP_STAGE_INIT
2091  * - \ref SCIP_STAGE_PROBLEM
2092  * - \ref SCIP_STAGE_TRANSFORMED
2093  * - \ref SCIP_STAGE_INITPRESOLVE
2094  * - \ref SCIP_STAGE_PRESOLVING
2095  * - \ref SCIP_STAGE_EXITPRESOLVE
2096  * - \ref SCIP_STAGE_PRESOLVED
2097  * - \ref SCIP_STAGE_SOLVING
2098  * - \ref SCIP_STAGE_SOLVED
2099  */
2100 SCIP_EXPORT
2101 SCIP_RETCODE SCIPprintReoptStatistics(
2102  SCIP* scip, /**< SCIP data structure */
2103  FILE* file /**< output file (or NULL for standard output) */
2104  );
2105 
2106 /** outputs history statistics about branchings on variables
2107  *
2108  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2109  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2110  *
2111  * @pre This method can be called if SCIP is in one of the following stages:
2112  * - \ref SCIP_STAGE_INIT
2113  * - \ref SCIP_STAGE_PROBLEM
2114  * - \ref SCIP_STAGE_TRANSFORMED
2115  * - \ref SCIP_STAGE_INITPRESOLVE
2116  * - \ref SCIP_STAGE_PRESOLVING
2117  * - \ref SCIP_STAGE_EXITPRESOLVE
2118  * - \ref SCIP_STAGE_PRESOLVED
2119  * - \ref SCIP_STAGE_SOLVING
2120  * - \ref SCIP_STAGE_SOLVED
2121  */
2122 SCIP_EXPORT
2123 SCIP_RETCODE SCIPprintBranchingStatistics(
2124  SCIP* scip, /**< SCIP data structure */
2125  FILE* file /**< output file (or NULL for standard output) */
2126  );
2127 
2128 /** outputs node information display line
2129  *
2130  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2131  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2132  *
2133  * @pre This method can be called if SCIP is in one of the following stages:
2134  * - \ref SCIP_STAGE_SOLVING
2135  */
2136 SCIP_EXPORT
2137 SCIP_RETCODE SCIPprintDisplayLine(
2138  SCIP* scip, /**< SCIP data structure */
2139  FILE* file, /**< output file (or NULL for standard output) */
2140  SCIP_VERBLEVEL verblevel, /**< minimal verbosity level to actually display the information line */
2141  SCIP_Bool endline /**< should the line be terminated with a newline symbol? */
2142  );
2143 
2144 /** gets total number of implications between variables that are stored in the implication graph
2145  *
2146  * @return the total number of implications between variables that are stored in the implication graph
2147  *
2148  * @pre This method can be called if SCIP is in one of the following stages:
2149  * - \ref SCIP_STAGE_INITPRESOLVE
2150  * - \ref SCIP_STAGE_PRESOLVING
2151  * - \ref SCIP_STAGE_EXITPRESOLVE
2152  * - \ref SCIP_STAGE_PRESOLVED
2153  * - \ref SCIP_STAGE_INITSOLVE
2154  * - \ref SCIP_STAGE_SOLVING
2155  * - \ref SCIP_STAGE_SOLVED
2156  */
2157 SCIP_EXPORT
2158 int SCIPgetNImplications(
2159  SCIP* scip /**< SCIP data structure */
2160  );
2161 
2162 /** stores conflict graph of binary variables' implications into a file, which can be used as input for the DOT tool
2163  *
2164  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2165  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2166  *
2167  * @pre This method can be called if SCIP is in one of the following stages:
2168  * - \ref SCIP_STAGE_TRANSFORMED
2169  * - \ref SCIP_STAGE_INITPRESOLVE
2170  * - \ref SCIP_STAGE_PRESOLVING
2171  * - \ref SCIP_STAGE_EXITPRESOLVE
2172  * - \ref SCIP_STAGE_PRESOLVED
2173  * - \ref SCIP_STAGE_INITSOLVE
2174  * - \ref SCIP_STAGE_SOLVING
2175  * - \ref SCIP_STAGE_SOLVED
2176  * - \ref SCIP_STAGE_EXITSOLVE
2177  *
2178  * @deprecated because binary implications are now stored as cliques
2179  */
2180 SCIP_EXPORT
2181 SCIP_RETCODE SCIPwriteImplicationConflictGraph(
2182  SCIP* scip, /**< SCIP data structure */
2183  const char* filename /**< file name, or NULL for stdout */
2184  );
2185 
2186 
2187 /** update statistical information when a new solution was found */
2188 SCIP_EXPORT
2189 void SCIPstoreSolutionGap(
2190  SCIP* scip /**< SCIP data structure */
2191  );
2192 
2193 /**@} */
2194 
2195 #ifdef __cplusplus
2196 }
2197 #endif
2198 
2199 #endif
SCIPprintReoptStatistics
SCIP_RETCODE SCIPprintReoptStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:4162
SCIPgetAvgPseudocostCountCurrentRun
SCIP_Real SCIPgetAvgPseudocostCountCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)
Definition: scip_solvingstats.c:1861
SCIPgetFirstPrimalBound
SCIP_Real SCIPgetFirstPrimalBound(SCIP *scip)
Definition: scip_solvingstats.c:1500
SCIPgetNRootLPIterations
SCIP_Longint SCIPgetNRootLPIterations(SCIP *scip)
Definition: scip_solvingstats.c:482
SCIPprintSeparatorStatistics
void SCIPprintSeparatorStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:2930
SCIPgetAvgPseudocostScoreCurrentRun
SCIP_Real SCIPgetAvgPseudocostScoreCurrentRun(SCIP *scip)
Definition: scip_solvingstats.c:1954
SCIPprintConstraintStatistics
void SCIPprintConstraintStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:2615
SCIPgetFirstLPLowerboundRoot
SCIP_Real SCIPgetFirstLPLowerboundRoot(SCIP *scip)
Definition: scip_solvingstats.c:1487
SCIPgetNLPIterations
SCIP_Longint SCIPgetNLPIterations(SCIP *scip)
Definition: scip_solvingstats.c:438
SCIPgetDualboundRoot
SCIP_Real SCIPgetDualboundRoot(SCIP *scip)
Definition: scip_solvingstats.c:1418
SCIPgetCutoffbound
SCIP_Real SCIPgetCutoffbound(SCIP *scip)
Definition: scip_solvingstats.c:1576
SCIPgetPrimalbound
SCIP_Real SCIPgetPrimalbound(SCIP *scip)
Definition: scip_solvingstats.c:1522
SCIPupdateCutoffbound
SCIP_RETCODE SCIPupdateCutoffbound(SCIP *scip, SCIP_Real cutoffbound)
Definition: scip_solvingstats.c:1604
SCIPgetNSolsFound
SCIP_Longint SCIPgetNSolsFound(SCIP *scip)
Definition: scip_solvingstats.c:1731
SCIPgetNBarrierLPs
SCIP_Longint SCIPgetNBarrierLPs(SCIP *scip)
Definition: scip_solvingstats.c:591
SCIPprintConcsolverStatistics
void SCIPprintConcsolverStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:3723
SCIPgetAvgCutoffScoreCurrentRun
SCIP_Real SCIPgetAvgCutoffScoreCurrentRun(SCIP *scip)
Definition: scip_solvingstats.c:2222
SCIPgetNConflictDualproofsApplied
SCIP_Longint SCIPgetNConflictDualproofsApplied(SCIP *scip)
Definition: scip_solvingstats.c:1168
SCIPgetAvgConflictScore
SCIP_Real SCIPgetAvgConflictScore(SCIP *scip)
Definition: scip_solvingstats.c:1977
SCIPprintTransProblem
SCIP_RETCODE SCIPprintTransProblem(SCIP *scip, FILE *file, const char *extension, SCIP_Bool genericnames)
Definition: scip_solvingstats.c:2374
SCIPgetNDualLPs
SCIP_Longint SCIPgetNDualLPs(SCIP *scip)
Definition: scip_solvingstats.c:555
SCIPgetMaxDepth
int SCIPgetMaxDepth(SCIP *scip)
Definition: scip_solvingstats.c:1193
SCIPprintStatusStatistics
void SCIPprintStatusStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:2417
SCIPprintDisplayLine
SCIP_RETCODE SCIPprintDisplayLine(SCIP *scip, FILE *file, SCIP_VERBLEVEL verblevel, SCIP_Bool endline)
Definition: scip_solvingstats.c:4358
SCIPgetNPrimalResolveLPs
SCIP_Longint SCIPgetNPrimalResolveLPs(SCIP *scip)
Definition: scip_solvingstats.c:665
SCIPprintBendersStatistics
void SCIPprintBendersStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:3767
SCIPprintTransProblemStatistics
void SCIPprintTransProblemStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:2470
SCIPprintTimingStatistics
void SCIPprintTimingStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:3894
SCIPgetDeterministicTime
SCIP_Real SCIPgetDeterministicTime(SCIP *scip)
Definition: scip_solvingstats.c:2247
SCIPgetNStrongbranchs
SCIP_Longint SCIPgetNStrongbranchs(SCIP *scip)
Definition: scip_solvingstats.c:867
SCIP_RETCODE
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:54
SCIPprintHeuristicStatistics
void SCIPprintHeuristicStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:3139
SCIPgetAvgLowerbound
SCIP_Real SCIPgetAvgLowerbound(SCIP *scip)
Definition: scip_solvingstats.c:1315
SCIPgetNRootFirstLPIterations
SCIP_Longint SCIPgetNRootFirstLPIterations(SCIP *scip)
Definition: scip_solvingstats.c:501
SCIP_VERBLEVEL
enum SCIP_VerbLevel SCIP_VERBLEVEL
Definition: type_message.h:48
SCIPgetNNZs
SCIP_Longint SCIPgetNNZs(SCIP *scip)
Definition: scip_solvingstats.c:464
SCIPgetNRootStrongbranchLPIterations
SCIP_Longint SCIPgetNRootStrongbranchLPIterations(SCIP *scip)
Definition: scip_solvingstats.c:921
SCIPgetNActiveConss
int SCIPgetNActiveConss(SCIP *scip)
Definition: scip_solvingstats.c:1261
SCIPgetNBacktracks
SCIP_Longint SCIPgetNBacktracks(SCIP *scip)
Definition: scip_solvingstats.c:1241
SCIPgetNDivingLPIterations
SCIP_Longint SCIPgetNDivingLPIterations(SCIP *scip)
Definition: scip_solvingstats.c:849
SCIPprintPresolverStatistics
void SCIPprintPresolverStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:2497
type_retcode.h
type definitions for return codes for SCIP methods
SCIPgetNCutsFoundRound
int SCIPgetNCutsFoundRound(SCIP *scip)
Definition: scip_solvingstats.c:1043
SCIPgetNRootboundChgsRun
int SCIPgetNRootboundChgsRun(SCIP *scip)
Definition: scip_solvingstats.c:365
SCIPprintBranchruleStatistics
void SCIPprintBranchruleStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:3096
SCIPprintStatistics
SCIP_RETCODE SCIPprintStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:4109
SCIPgetAvgCutoffs
SCIP_Real SCIPgetAvgCutoffs(SCIP *scip, SCIP_BRANCHDIR dir)
Definition: scip_solvingstats.c:2161
SCIPgetLowerboundRoot
SCIP_Real SCIPgetLowerboundRoot(SCIP *scip)
Definition: scip_solvingstats.c:1442
SCIPprintBranchingStatistics
SCIP_RETCODE SCIPprintBranchingStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:4243
SCIPgetNDualResolveLPIterations
SCIP_Longint SCIPgetNDualResolveLPIterations(SCIP *scip)
Definition: scip_solvingstats.c:723
SCIP_BRANCHDIR
enum SCIP_BranchDir SCIP_BRANCHDIR
Definition: type_history.h:39
SCIPgetFirstLPDualboundRoot
SCIP_Real SCIPgetFirstLPDualboundRoot(SCIP *scip)
Definition: scip_solvingstats.c:1466
SCIPgetNCutsApplied
int SCIPgetNCutsApplied(SCIP *scip)
Definition: scip_solvingstats.c:1061
SCIPgetNNodeLPs
SCIP_Longint SCIPgetNNodeLPs(SCIP *scip)
Definition: scip_solvingstats.c:741
SCIPstoreSolutionGap
void SCIPstoreSolutionGap(SCIP *scip)
Definition: scip_solvingstats.c:4427
SCIPgetNCutsFound
int SCIPgetNCutsFound(SCIP *scip)
Definition: scip_solvingstats.c:1025
SCIPgetDualbound
SCIP_Real SCIPgetDualbound(SCIP *scip)
Definition: scip_solvingstats.c:1339
type_scip.h
type definitions for SCIP&#39;s main datastructure
SCIPgetTransGap
SCIP_Real SCIPgetTransGap(SCIP *scip)
Definition: scip_solvingstats.c:1693
SCIPgetNResolveLPIterations
SCIP_Longint SCIPgetNResolveLPIterations(SCIP *scip)
Definition: scip_solvingstats.c:647
SCIPprintConflictStatistics
void SCIPprintConflictStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:2798
SCIPprintCompressionStatistics
void SCIPprintCompressionStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:3250
SCIPgetNRootboundChgs
int SCIPgetNRootboundChgs(SCIP *scip)
Definition: scip_solvingstats.c:338
SCIPprintLPStatistics
void SCIPprintLPStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:3287
SCIPgetNDelayedCutoffs
SCIP_Longint SCIPgetNDelayedCutoffs(SCIP *scip)
Definition: scip_solvingstats.c:392
SCIPprintOrigProblem
SCIP_RETCODE SCIPprintOrigProblem(SCIP *scip, FILE *file, const char *extension, SCIP_Bool genericnames)
Definition: scip_solvingstats.c:2330
SCIPprintPropagatorStatistics
void SCIPprintPropagatorStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:2735
SCIPgetLowerbound
SCIP_Real SCIPgetLowerbound(SCIP *scip)
Definition: scip_solvingstats.c:1366
SCIPisPrimalboundSol
SCIP_Bool SCIPisPrimalboundSol(SCIP *scip)
Definition: scip_solvingstats.c:1636
SCIPgetAvgPseudocostCurrentRun
SCIP_Real SCIPgetAvgPseudocostCurrentRun(SCIP *scip, SCIP_Real solvaldelta)
Definition: scip_solvingstats.c:1822
SCIPgetNTotalNodes
SCIP_Longint SCIPgetNTotalNodes(SCIP *scip)
Definition: scip_solvingstats.c:230
SCIPgetNBarrierLPIterations
SCIP_Longint SCIPgetNBarrierLPIterations(SCIP *scip)
Definition: scip_solvingstats.c:609
SCIPgetNPrimalResolveLPIterations
SCIP_Longint SCIPgetNPrimalResolveLPIterations(SCIP *scip)
Definition: scip_solvingstats.c:685
SCIPprintRootStatistics
void SCIPprintRootStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:3829
SCIPgetNNodeLPIterations
SCIP_Longint SCIPgetNNodeLPIterations(SCIP *scip)
Definition: scip_solvingstats.c:777
SCIPgetAvgInferencesCurrentRun
SCIP_Real SCIPgetAvgInferencesCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)
Definition: scip_solvingstats.c:2095
SCIP_Bool
#define SCIP_Bool
Definition: def.h:84
SCIPgetMaxTotalDepth
int SCIPgetMaxTotalDepth(SCIP *scip)
Definition: scip_solvingstats.c:1217
SCIPprintRelaxatorStatistics
void SCIPprintRelaxatorStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:3429
SCIPprintTreeStatistics
void SCIPprintTreeStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:3471
SCIPprintSolutionStatistics
void SCIPprintSolutionStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:3521
SCIPgetPseudocostVariance
SCIP_Real SCIPgetPseudocostVariance(SCIP *scip, SCIP_BRANCHDIR branchdir, SCIP_Bool onlycurrentrun)
Definition: scip_solvingstats.c:1903
SCIPgetGap
SCIP_Real SCIPgetGap(SCIP *scip)
Definition: scip_solvingstats.c:1659
SCIPgetAvgConflictlengthScoreCurrentRun
SCIP_Real SCIPgetAvgConflictlengthScoreCurrentRun(SCIP *scip)
Definition: scip_solvingstats.c:2052
SCIPprintExpressionHandlerStatistics
void SCIPprintExpressionHandlerStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:3956
SCIPwriteImplicationConflictGraph
SCIP_RETCODE SCIPwriteImplicationConflictGraph(SCIP *scip, const char *filename)
Definition: scip_solvingstats.c:4416
SCIPgetNPrimalLPs
SCIP_Longint SCIPgetNPrimalLPs(SCIP *scip)
Definition: scip_solvingstats.c:519
SCIPgetNConflictConssFound
SCIP_Longint SCIPgetNConflictConssFound(SCIP *scip)
Definition: scip_solvingstats.c:1085
SCIPgetAvgCutoffsCurrentRun
SCIP_Real SCIPgetAvgCutoffsCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)
Definition: scip_solvingstats.c:2181
SCIPprintNLPStatistics
void SCIPprintNLPStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:3403
SCIPgetNDualResolveLPs
SCIP_Longint SCIPgetNDualResolveLPs(SCIP *scip)
Definition: scip_solvingstats.c:703
SCIPgetNDualLPIterations
SCIP_Longint SCIPgetNDualLPIterations(SCIP *scip)
Definition: scip_solvingstats.c:573
SCIPgetNRuns
int SCIPgetNRuns(SCIP *scip)
Definition: scip_solvingstats.c:120
SCIPgetNConflictConssApplied
SCIP_Longint SCIPgetNConflictConssApplied(SCIP *scip)
Definition: scip_solvingstats.c:1144
SCIPgetNObjlimLeaves
SCIP_Longint SCIPgetNObjlimLeaves(SCIP *scip)
Definition: scip_solvingstats.c:311
SCIPprintNLPIStatistics
void SCIPprintNLPIStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:4015
SCIPprintPricerStatistics
void SCIPprintPricerStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:3058
SCIPgetAvgDualbound
SCIP_Real SCIPgetAvgDualbound(SCIP *scip)
Definition: scip_solvingstats.c:1296
SCIPgetNResolveLPs
SCIP_Longint SCIPgetNResolveLPs(SCIP *scip)
Definition: scip_solvingstats.c:627
SCIPgetAvgCutoffScore
SCIP_Real SCIPgetAvgCutoffScore(SCIP *scip)
Definition: scip_solvingstats.c:2199
SCIPgetNNodeInitLPIterations
SCIP_Longint SCIPgetNNodeInitLPIterations(SCIP *scip)
Definition: scip_solvingstats.c:813
SCIPgetNNodeInitLPs
SCIP_Longint SCIPgetNNodeInitLPs(SCIP *scip)
Definition: scip_solvingstats.c:795
SCIPgetAvgConflictlengthScore
SCIP_Real SCIPgetAvgConflictlengthScore(SCIP *scip)
Definition: scip_solvingstats.c:2027
SCIPgetNStrongbranchLPIterations
SCIP_Longint SCIPgetNStrongbranchLPIterations(SCIP *scip)
Definition: scip_solvingstats.c:885
SCIPgetNReoptRuns
int SCIPgetNReoptRuns(SCIP *scip)
Definition: scip_solvingstats.c:147
SCIPgetNDivingLPs
SCIP_Longint SCIPgetNDivingLPs(SCIP *scip)
Definition: scip_solvingstats.c:831
SCIPprintCutselectorStatistics
void SCIPprintCutselectorStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:3025
SCIPgetNPricevars
int SCIPgetNPricevars(SCIP *scip)
Definition: scip_solvingstats.c:955
SCIPgetNPrimalLPIterations
SCIP_Longint SCIPgetNPrimalLPIterations(SCIP *scip)
Definition: scip_solvingstats.c:537
SCIPgetAvgPseudocostCount
SCIP_Real SCIPgetAvgPseudocostCount(SCIP *scip, SCIP_BRANCHDIR dir)
Definition: scip_solvingstats.c:1840
SCIPgetNPriceRounds
int SCIPgetNPriceRounds(SCIP *scip)
Definition: scip_solvingstats.c:937
SCIPgetNImplications
int SCIPgetNImplications(SCIP *scip)
Definition: scip_solvingstats.c:4388
SCIPgetAvgInferenceScoreCurrentRun
SCIP_Real SCIPgetAvgInferenceScoreCurrentRun(SCIP *scip)
Definition: scip_solvingstats.c:2138
SCIPgetNBestSolsFound
SCIP_Longint SCIPgetNBestSolsFound(SCIP *scip)
Definition: scip_solvingstats.c:1785
SCIP_Real
#define SCIP_Real
Definition: def.h:177
SCIPgetNPricevarsFound
int SCIPgetNPricevarsFound(SCIP *scip)
Definition: scip_solvingstats.c:973
type_history.h
type definitions for branching and inference history
SCIPprintConstraintTimingStatistics
void SCIPprintConstraintTimingStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:2674
SCIPgetNConflictConssFoundNode
int SCIPgetNConflictConssFoundNode(SCIP *scip)
Definition: scip_solvingstats.c:1120
SCIP_Longint
#define SCIP_Longint
Definition: def.h:162
type_message.h
type definitions for message output methods
SCIPgetAvgPseudocostScore
SCIP_Real SCIPgetAvgPseudocostScore(SCIP *scip)
Definition: scip_solvingstats.c:1880
SCIPgetNLimSolsFound
SCIP_Longint SCIPgetNLimSolsFound(SCIP *scip)
Definition: scip_solvingstats.c:1758
nnodes
#define nnodes
Definition: gastrans.c:65
SCIPgetNPricevarsApplied
int SCIPgetNPricevarsApplied(SCIP *scip)
Definition: scip_solvingstats.c:991
SCIPgetAvgPseudocost
SCIP_Real SCIPgetAvgPseudocost(SCIP *scip, SCIP_Real solvaldelta)
Definition: scip_solvingstats.c:1802
SCIPgetUpperbound
SCIP_Real SCIPgetUpperbound(SCIP *scip)
Definition: scip_solvingstats.c:1546
def.h
common defines and data types used in all packages of SCIP
SCIPgetNNodeZeroIterationLPs
SCIP_Longint SCIPgetNNodeZeroIterationLPs(SCIP *scip)
Definition: scip_solvingstats.c:759
SCIPaddNNodes
void SCIPaddNNodes(SCIP *scip, SCIP_Longint nnodes)
Definition: scip_solvingstats.c:174
SCIPgetNEnabledConss
int SCIPgetNEnabledConss(SCIP *scip)
Definition: scip_solvingstats.c:1278
SCIPgetNNodes
SCIP_Longint SCIPgetNNodes(SCIP *scip)
Definition: scip_solvingstats.c:203
SCIPgetNLPs
SCIP_Longint SCIPgetNLPs(SCIP *scip)
Definition: scip_solvingstats.c:419
SCIPgetNInfeasibleLeaves
SCIP_Longint SCIPgetNInfeasibleLeaves(SCIP *scip)
Definition: scip_solvingstats.c:284
SCIPgetAvgConflictScoreCurrentRun
SCIP_Real SCIPgetAvgConflictScoreCurrentRun(SCIP *scip)
Definition: scip_solvingstats.c:2002
SCIPprintOrigProblemStatistics
void SCIPprintOrigProblemStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:2444
SCIPgetNFeasibleLeaves
SCIP_Longint SCIPgetNFeasibleLeaves(SCIP *scip)
Definition: scip_solvingstats.c:257
SCIPgetNRootStrongbranchs
SCIP_Longint SCIPgetNRootStrongbranchs(SCIP *scip)
Definition: scip_solvingstats.c:903
SCIPgetAvgInferenceScore
SCIP_Real SCIPgetAvgInferenceScore(SCIP *scip)
Definition: scip_solvingstats.c:2113
SCIPgetNSepaRounds
int SCIPgetNSepaRounds(SCIP *scip)
Definition: scip_solvingstats.c:1007
SCIPgetPseudocostCount
SCIP_Real SCIPgetPseudocostCount(SCIP *scip, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun)
Definition: scip_solvingstats.c:1928
SCIPgetAvgInferences
SCIP_Real SCIPgetAvgInferences(SCIP *scip, SCIP_BRANCHDIR dir)
Definition: scip_solvingstats.c:2075