Scippy

SCIP

Solving Constraint Integer Programs

scip_solvingstats.c
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the program and library */
4 /* SCIP --- Solving Constraint Integer Programs */
5 /* */
6 /* Copyright (C) 2002-2018 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SCIP is distributed under the terms of the ZIB Academic License. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SCIP; see the file COPYING. If not visit scip.zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file scip_solvingstats.c
17  * @brief public methods for querying solving statistics
18  * @author Tobias Achterberg
19  * @author Timo Berthold
20  * @author Gerald Gamrath
21  * @author Robert Lion Gottwald
22  * @author Stefan Heinz
23  * @author Gregor Hendel
24  * @author Thorsten Koch
25  * @author Alexander Martin
26  * @author Marc Pfetsch
27  * @author Michael Winkler
28  * @author Kati Wolter
29  *
30  * @todo check all SCIP_STAGE_* switches, and include the new stages TRANSFORMED and INITSOLVE
31  */
32 
33 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
34 
35 #include <ctype.h>
36 #include <stdarg.h>
37 #include <assert.h>
38 #include <string.h>
39 #if defined(_WIN32) || defined(_WIN64)
40 #else
41 #include <strings.h> /*lint --e{766}*/
42 #endif
43 
44 
45 #include "lpi/lpi.h"
46 #include "nlpi/exprinterpret.h"
47 #include "nlpi/nlpi.h"
48 #include "scip/benders.h"
49 #include "scip/benderscut.h"
50 #include "scip/branch.h"
51 #include "scip/branch_nodereopt.h"
52 #include "scip/clock.h"
53 #include "scip/compr.h"
54 #include "scip/concsolver.h"
55 #include "scip/concurrent.h"
56 #include "scip/conflict.h"
57 #include "scip/conflictstore.h"
58 #include "scip/cons.h"
59 #include "scip/cons_linear.h"
60 #include "scip/cutpool.h"
61 #include "scip/cuts.h"
62 #include "scip/debug.h"
63 #include "scip/def.h"
64 #include "scip/dialog.h"
65 #include "scip/dialog_default.h"
66 #include "scip/disp.h"
67 #include "scip/event.h"
68 #include "scip/heur.h"
69 #include "scip/heur_ofins.h"
70 #include "scip/heur_reoptsols.h"
72 #include "scip/heuristics.h"
73 #include "scip/history.h"
74 #include "scip/implics.h"
75 #include "scip/interrupt.h"
76 #include "scip/lp.h"
77 #include "scip/mem.h"
78 #include "scip/message_default.h"
79 #include "scip/misc.h"
80 #include "scip/nlp.h"
81 #include "scip/nodesel.h"
82 #include "scip/paramset.h"
83 #include "scip/presol.h"
84 #include "scip/presolve.h"
85 #include "scip/pricer.h"
86 #include "scip/pricestore.h"
87 #include "scip/primal.h"
88 #include "scip/prob.h"
89 #include "scip/prop.h"
90 #include "scip/reader.h"
91 #include "scip/relax.h"
92 #include "scip/reopt.h"
93 #include "scip/retcode.h"
94 #include "scip/scipbuildflags.h"
95 #include "scip/scipcoreplugins.h"
96 #include "scip/scipgithash.h"
97 #include "scip/sepa.h"
98 #include "scip/sepastore.h"
99 #include "scip/set.h"
100 #include "scip/sol.h"
101 #include "scip/solve.h"
102 #include "scip/stat.h"
103 #include "scip/syncstore.h"
104 #include "scip/table.h"
105 #include "scip/tree.h"
106 #include "scip/var.h"
107 #include "scip/visual.h"
108 #include "xml/xml.h"
109 
110 #include "scip/scip_benders.h"
111 #include "scip/scip_general.h"
112 #include "scip/scip_mem.h"
113 #include "scip/scip_message.h"
114 #include "scip/scip_numerics.h"
115 #include "scip/scip_sol.h"
116 #include "scip/scip_solvingstats.h"
117 #include "scip/scip_table.h"
118 #include "scip/scip_timing.h"
119 #include "scip/scip_var.h"
120 
121 #include "scip/pub_benderscut.h"
122 #include "scip/pub_benders.h"
123 #include "scip/pub_branch.h"
124 #include "scip/pub_compr.h"
125 #include "scip/pub_cons.h"
126 #include "scip/pub_cutpool.h"
127 #include "scip/pub_heur.h"
128 #include "scip/pub_history.h"
129 #include "scip/pub_message.h"
130 #include "scip/pub_misc.h"
131 #include "scip/pub_misc_sort.h"
132 #include "scip/pub_presol.h"
133 #include "scip/pub_pricer.h"
134 #include "scip/pub_prop.h"
135 #include "scip/pub_reader.h"
136 #include "scip/pub_relax.h"
137 #include "scip/pub_reopt.h"
138 #include "scip/pub_sepa.h"
139 #include "scip/pub_sol.h"
140 #include "scip/pub_table.h"
141 #include "scip/pub_var.h"
142 
143 
144 /* In debug mode, we include the SCIP's structure in scip.c, such that no one can access
145  * this structure except the interface methods in scip.c.
146  * In optimized mode, the structure is included in scip.h, because some of the methods
147  * are implemented as defines for performance reasons (e.g. the numerical comparisons)
148  */
149 #ifndef NDEBUG
150 #include "scip/struct_scip.h"
151 #endif
152 
153 /** gets number of branch and bound runs performed, including the current run
154  *
155  * @return the number of branch and bound runs performed, including the current run
156  *
157  * @pre This method can be called if SCIP is in one of the following stages:
158  * - \ref SCIP_STAGE_PROBLEM
159  * - \ref SCIP_STAGE_TRANSFORMING
160  * - \ref SCIP_STAGE_TRANSFORMED
161  * - \ref SCIP_STAGE_INITPRESOLVE
162  * - \ref SCIP_STAGE_PRESOLVING
163  * - \ref SCIP_STAGE_EXITPRESOLVE
164  * - \ref SCIP_STAGE_PRESOLVED
165  * - \ref SCIP_STAGE_INITSOLVE
166  * - \ref SCIP_STAGE_SOLVING
167  * - \ref SCIP_STAGE_SOLVED
168  * - \ref SCIP_STAGE_EXITSOLVE
169  * - \ref SCIP_STAGE_FREETRANS
170  */
172  SCIP* scip /**< SCIP data structure */
173  )
174 {
175  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNRuns", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
176 
177  return scip->stat->nruns;
178 }
179 
180 /** gets number of reoptimization runs performed, including the current run
181  *
182  * @return the number of reoptimization runs performed, including the current run
183  *
184  * @pre This method can be called if SCIP is in one of the following stages:
185  * - \ref SCIP_STAGE_PROBLEM
186  * - \ref SCIP_STAGE_TRANSFORMING
187  * - \ref SCIP_STAGE_TRANSFORMED
188  * - \ref SCIP_STAGE_INITPRESOLVE
189  * - \ref SCIP_STAGE_PRESOLVING
190  * - \ref SCIP_STAGE_EXITPRESOLVE
191  * - \ref SCIP_STAGE_PRESOLVED
192  * - \ref SCIP_STAGE_INITSOLVE
193  * - \ref SCIP_STAGE_SOLVING
194  * - \ref SCIP_STAGE_SOLVED
195  * - \ref SCIP_STAGE_EXITSOLVE
196  * - \ref SCIP_STAGE_FREETRANS
197  */
199  SCIP* scip /**< SCIP data structure */
200  )
201 {
202  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNReoptRuns", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
203 
204  return scip->stat->nreoptruns;
205 }
206 
207 /** add given number to the number of processed nodes in current run and in all runs, including the focus node
208  *
209  * @return the number of processed nodes in current run, including the focus node
210  *
211  * @pre This method can be called if SCIP is in one of the following stages:
212  * - \ref SCIP_STAGE_PROBLEM
213  * - \ref SCIP_STAGE_TRANSFORMING
214  * - \ref SCIP_STAGE_TRANSFORMED
215  * - \ref SCIP_STAGE_INITPRESOLVE
216  * - \ref SCIP_STAGE_PRESOLVING
217  * - \ref SCIP_STAGE_EXITPRESOLVE
218  * - \ref SCIP_STAGE_PRESOLVED
219  * - \ref SCIP_STAGE_INITSOLVE
220  * - \ref SCIP_STAGE_SOLVING
221  * - \ref SCIP_STAGE_SOLVED
222  * - \ref SCIP_STAGE_EXITSOLVE
223  * - \ref SCIP_STAGE_FREETRANS
224  */
226  SCIP* scip, /**< SCIP data structure */
227  SCIP_Longint nnodes /**< number of processed nodes to add to the statistics */
228  )
229 {
230  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPaddNNodes", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
231 
232  scip->stat->nnodes += nnodes;
233  scip->stat->ntotalnodes += nnodes;
234 }
235 
236 /** gets number of processed nodes in current run, including the focus node
237  *
238  * @return the number of processed nodes in current run, including the focus node
239  *
240  * @pre This method can be called if SCIP is in one of the following stages:
241  * - \ref SCIP_STAGE_PROBLEM
242  * - \ref SCIP_STAGE_TRANSFORMING
243  * - \ref SCIP_STAGE_TRANSFORMED
244  * - \ref SCIP_STAGE_INITPRESOLVE
245  * - \ref SCIP_STAGE_PRESOLVING
246  * - \ref SCIP_STAGE_EXITPRESOLVE
247  * - \ref SCIP_STAGE_PRESOLVED
248  * - \ref SCIP_STAGE_INITSOLVE
249  * - \ref SCIP_STAGE_SOLVING
250  * - \ref SCIP_STAGE_SOLVED
251  * - \ref SCIP_STAGE_EXITSOLVE
252  * - \ref SCIP_STAGE_FREETRANS
253  */
255  SCIP* scip /**< SCIP data structure */
256  )
257 {
258  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNNodes", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
259 
260  return scip->stat->nnodes;
261 }
262 
263 /** gets total number of processed nodes in all runs, including the focus node
264  *
265  * @return the total number of processed nodes in all runs, including the focus node
266  *
267  * @pre This method can be called if SCIP is in one of the following stages:
268  * - \ref SCIP_STAGE_PROBLEM
269  * - \ref SCIP_STAGE_TRANSFORMING
270  * - \ref SCIP_STAGE_TRANSFORMED
271  * - \ref SCIP_STAGE_INITPRESOLVE
272  * - \ref SCIP_STAGE_PRESOLVING
273  * - \ref SCIP_STAGE_EXITPRESOLVE
274  * - \ref SCIP_STAGE_PRESOLVED
275  * - \ref SCIP_STAGE_INITSOLVE
276  * - \ref SCIP_STAGE_SOLVING
277  * - \ref SCIP_STAGE_SOLVED
278  * - \ref SCIP_STAGE_EXITSOLVE
279  * - \ref SCIP_STAGE_FREETRANS
280  */
282  SCIP* scip /**< SCIP data structure */
283  )
284 {
285  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNTotalNodes", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
286 
287  return scip->stat->ntotalnodes;
288 }
289 
290 /** gets number of leaf nodes processed with feasible relaxation solution
291  *
292  * @return number of leaf nodes processed with feasible relaxation solution
293  *
294  * @pre This method can be called if SCIP is in one of the following stages:
295  * - \ref SCIP_STAGE_PROBLEM
296  * - \ref SCIP_STAGE_TRANSFORMING
297  * - \ref SCIP_STAGE_TRANSFORMED
298  * - \ref SCIP_STAGE_INITPRESOLVE
299  * - \ref SCIP_STAGE_PRESOLVING
300  * - \ref SCIP_STAGE_EXITPRESOLVE
301  * - \ref SCIP_STAGE_PRESOLVED
302  * - \ref SCIP_STAGE_INITSOLVE
303  * - \ref SCIP_STAGE_SOLVING
304  * - \ref SCIP_STAGE_SOLVED
305  * - \ref SCIP_STAGE_EXITSOLVE
306  * - \ref SCIP_STAGE_FREETRANS
307  */
309  SCIP* scip /**< SCIP data structure */
310  )
311 {
312  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNFeasibleLeaves", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
313 
314  return scip->stat->nfeasleaves;
315 }
316 
317 /** gets number of infeasible leaf nodes processed
318  *
319  * @return number of infeasible leaf nodes processed
320  *
321  * @pre This method can be called if SCIP is in one of the following stages:
322  * - \ref SCIP_STAGE_PROBLEM
323  * - \ref SCIP_STAGE_TRANSFORMING
324  * - \ref SCIP_STAGE_TRANSFORMED
325  * - \ref SCIP_STAGE_INITPRESOLVE
326  * - \ref SCIP_STAGE_PRESOLVING
327  * - \ref SCIP_STAGE_EXITPRESOLVE
328  * - \ref SCIP_STAGE_PRESOLVED
329  * - \ref SCIP_STAGE_INITSOLVE
330  * - \ref SCIP_STAGE_SOLVING
331  * - \ref SCIP_STAGE_SOLVED
332  * - \ref SCIP_STAGE_EXITSOLVE
333  * - \ref SCIP_STAGE_FREETRANS
334  */
336  SCIP* scip /**< SCIP data structure */
337  )
338 {
339  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNInfeasibleLeaves", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
340 
341  return scip->stat->ninfeasleaves;
342 }
343 
344 /** gets number of processed leaf nodes that hit LP objective limit
345  *
346  * @return number of processed leaf nodes that hit LP objective limit
347  *
348  * @pre This method can be called if SCIP is in one of the following stages:
349  * - \ref SCIP_STAGE_PROBLEM
350  * - \ref SCIP_STAGE_TRANSFORMING
351  * - \ref SCIP_STAGE_TRANSFORMED
352  * - \ref SCIP_STAGE_INITPRESOLVE
353  * - \ref SCIP_STAGE_PRESOLVING
354  * - \ref SCIP_STAGE_EXITPRESOLVE
355  * - \ref SCIP_STAGE_PRESOLVED
356  * - \ref SCIP_STAGE_INITSOLVE
357  * - \ref SCIP_STAGE_SOLVING
358  * - \ref SCIP_STAGE_SOLVED
359  * - \ref SCIP_STAGE_EXITSOLVE
360  * - \ref SCIP_STAGE_FREETRANS
361  */
363  SCIP* scip /**< Scip data structure */
364  )
365 {
366  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNObjlimLeaves", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
367 
368  return scip->stat->nobjleaves;
369 }
370 
371 
372 /** gets number of times a selected node was from a cut off subtree
373  *
374  * @return number of times a selected node was from a cut off subtree
375  *
376  * @pre This method can be called if SCIP is in one of the following stages:
377  * - \ref SCIP_STAGE_PROBLEM
378  * - \ref SCIP_STAGE_TRANSFORMING
379  * - \ref SCIP_STAGE_TRANSFORMED
380  * - \ref SCIP_STAGE_INITPRESOLVE
381  * - \ref SCIP_STAGE_PRESOLVING
382  * - \ref SCIP_STAGE_EXITPRESOLVE
383  * - \ref SCIP_STAGE_PRESOLVED
384  * - \ref SCIP_STAGE_INITSOLVE
385  * - \ref SCIP_STAGE_SOLVING
386  * - \ref SCIP_STAGE_SOLVED
387  * - \ref SCIP_STAGE_EXITSOLVE
388  * - \ref SCIP_STAGE_FREETRANS
389  */
391  SCIP* scip /**< SCIP data structure */
392  )
393 {
394  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNDelayedCutoffs", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
395 
396  return scip->stat->ndelayedcutoffs;
397 }
398 
399 /** gets total number of LPs solved so far
400  *
401  * @return the total number of LPs solved so far
402  *
403  * @pre This method can be called if SCIP is in one of the following stages:
404  * - \ref SCIP_STAGE_PROBLEM
405  * - \ref SCIP_STAGE_TRANSFORMING
406  * - \ref SCIP_STAGE_TRANSFORMED
407  * - \ref SCIP_STAGE_INITPRESOLVE
408  * - \ref SCIP_STAGE_PRESOLVING
409  * - \ref SCIP_STAGE_EXITPRESOLVE
410  * - \ref SCIP_STAGE_PRESOLVED
411  * - \ref SCIP_STAGE_INITSOLVE
412  * - \ref SCIP_STAGE_SOLVING
413  * - \ref SCIP_STAGE_SOLVED
414  * - \ref SCIP_STAGE_EXITSOLVE
415  * - \ref SCIP_STAGE_FREETRANS
416  */
418  SCIP* scip /**< SCIP data structure */
419  )
420 {
421  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNLPs", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
422 
423  return scip->stat->nlps;
424 }
425 
426 /** gets total number of iterations used so far in primal and dual simplex and barrier algorithm
427  *
428  * @return the total number of iterations used so far in primal and dual simplex and barrier algorithm
429  *
430  * @pre This method can be called if SCIP is in one of the following stages:
431  * - \ref SCIP_STAGE_PRESOLVING
432  * - \ref SCIP_STAGE_PRESOLVED
433  * - \ref SCIP_STAGE_SOLVING
434  * - \ref SCIP_STAGE_SOLVED
435  */
437  SCIP* scip /**< SCIP data structure */
438  )
439 {
440  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
441 
442  return scip->stat->nlpiterations;
443 }
444 
445 /** gets number of active non-zeros in the current transformed problem
446  *
447  * @return the number of active non-zeros in the current transformed problem
448  *
449  * @pre This method can be called if SCIP is in one of the following stages:
450  * - \ref SCIP_STAGE_PROBLEM
451  * - \ref SCIP_STAGE_TRANSFORMING
452  * - \ref SCIP_STAGE_TRANSFORMED
453  * - \ref SCIP_STAGE_INITPRESOLVE
454  * - \ref SCIP_STAGE_PRESOLVING
455  * - \ref SCIP_STAGE_EXITPRESOLVE
456  * - \ref SCIP_STAGE_PRESOLVED
457  * - \ref SCIP_STAGE_INITSOLVE
458  * - \ref SCIP_STAGE_SOLVING
459  * - \ref SCIP_STAGE_SOLVED
460  * - \ref SCIP_STAGE_EXITSOLVE
461  */
463  SCIP* scip /**< SCIP data structure */
464  )
465 {
466  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNNZs", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
467 
468  return scip->stat->nnz;
469 }
470 
471 /** gets total number of iterations used so far in primal and dual simplex and barrier algorithm for the root node
472  *
473  * @return the total number of iterations used so far in primal and dual simplex and barrier algorithm for the root node
474  *
475  * @pre This method can be called if SCIP is in one of the following stages:
476  * - \ref SCIP_STAGE_PRESOLVED
477  * - \ref SCIP_STAGE_SOLVING
478  * - \ref SCIP_STAGE_SOLVED
479  */
481  SCIP* scip /**< SCIP data structure */
482  )
483 {
484  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNRootLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
485 
486  return scip->stat->nrootlpiterations;
487 }
488 
489 /** gets total number of iterations used in primal and dual simplex and barrier algorithm for the first LP at the root
490  * node
491  *
492  * @return the total number of iterations used in primal and dual simplex and barrier algorithm for the first root LP
493  *
494  * @pre This method can be called if SCIP is in one of the following stages:
495  * - \ref SCIP_STAGE_PRESOLVED
496  * - \ref SCIP_STAGE_SOLVING
497  * - \ref SCIP_STAGE_SOLVED
498  */
500  SCIP* scip /**< SCIP data structure */
501  )
502 {
503  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNRootFirstLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
504 
505  return scip->stat->nrootfirstlpiterations;
506 }
507 
508 /** gets total number of primal LPs solved so far
509  *
510  * @return the total number of primal LPs solved so far
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  */
518  SCIP* scip /**< SCIP data structure */
519  )
520 {
521  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNPrimalLPs", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
522 
523  return scip->stat->nprimallps;
524 }
525 
526 /** gets total number of iterations used so far in primal simplex
527  *
528  * @return total number of iterations used so far in primal simplex
529  *
530  * @pre This method can be called if SCIP is in one of the following stages:
531  * - \ref SCIP_STAGE_PRESOLVED
532  * - \ref SCIP_STAGE_SOLVING
533  * - \ref SCIP_STAGE_SOLVED
534  */
536  SCIP* scip /**< SCIP data structure */
537  )
538 {
539  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNPrimalLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
540 
541  return scip->stat->nprimallpiterations;
542 }
543 
544 /** gets total number of dual LPs solved so far
545  *
546  * @return the total number of dual LPs solved so far
547  *
548  * @pre This method can be called if SCIP is in one of the following stages:
549  * - \ref SCIP_STAGE_PRESOLVED
550  * - \ref SCIP_STAGE_SOLVING
551  * - \ref SCIP_STAGE_SOLVED
552  */
554  SCIP* scip /**< SCIP data structure */
555  )
556 {
557  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNDualLPs", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
558 
559  return scip->stat->nduallps;
560 }
561 
562 /** gets total number of iterations used so far in dual simplex
563  *
564  * @return the total number of iterations used so far in dual simplex
565  *
566  * @pre This method can be called if SCIP is in one of the following stages:
567  * - \ref SCIP_STAGE_PRESOLVED
568  * - \ref SCIP_STAGE_SOLVING
569  * - \ref SCIP_STAGE_SOLVED
570  */
572  SCIP* scip /**< SCIP data structure */
573  )
574 {
575  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNDualLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
576 
577  return scip->stat->nduallpiterations;
578 }
579 
580 /** gets total number of barrier LPs solved so far
581  *
582  * @return the total number of barrier LPs solved so far
583  *
584  * @pre This method can be called if SCIP is in one of the following stages:
585  * - \ref SCIP_STAGE_PRESOLVED
586  * - \ref SCIP_STAGE_SOLVING
587  * - \ref SCIP_STAGE_SOLVED
588  */
590  SCIP* scip /**< SCIP data structure */
591  )
592 {
593  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNBarrierLPs", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
594 
595  return scip->stat->nbarrierlps;
596 }
597 
598 /** gets total number of iterations used so far in barrier algorithm
599  *
600  * @return the total number of iterations used so far in barrier algorithm
601  *
602  * @pre This method can be called if SCIP is in one of the following stages:
603  * - \ref SCIP_STAGE_PRESOLVED
604  * - \ref SCIP_STAGE_SOLVING
605  * - \ref SCIP_STAGE_SOLVED
606  */
608  SCIP* scip /**< SCIP data structure */
609  )
610 {
611  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNBarrierLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
612 
613  return scip->stat->nbarrierlpiterations;
614 }
615 
616 /** gets total number of LPs solved so far that were resolved from an advanced start basis
617  *
618  * @return the total number of LPs solved so far that were resolved from an advanced start basis
619  *
620  * @pre This method can be called if SCIP is in one of the following stages:
621  * - \ref SCIP_STAGE_PRESOLVED
622  * - \ref SCIP_STAGE_SOLVING
623  * - \ref SCIP_STAGE_SOLVED
624  */
626  SCIP* scip /**< SCIP data structure */
627  )
628 {
629  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNResolveLPs", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
630 
631  return scip->stat->nprimalresolvelps + scip->stat->ndualresolvelps;
632 }
633 
634 /** gets total number of simplex iterations used so far in primal and dual simplex calls where an advanced start basis
635  * was available
636  *
637  * @return the total number of simplex iterations used so far in primal and dual simplex calls where an advanced start
638  * basis was available
639  *
640  * @pre This method can be called if SCIP is in one of the following stages:
641  * - \ref SCIP_STAGE_PRESOLVED
642  * - \ref SCIP_STAGE_SOLVING
643  * - \ref SCIP_STAGE_SOLVED
644  */
646  SCIP* scip /**< SCIP data structure */
647  )
648 {
649  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNResolveLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
650 
652 }
653 
654 /** gets total number of primal LPs solved so far that were resolved from an advanced start basis
655  *
656  * @return the total number of primal LPs solved so far that were resolved from an advanced start basis
657  *
658  * @pre This method can be called if SCIP is in one of the following stages:
659  * - \ref SCIP_STAGE_PRESOLVED
660  * - \ref SCIP_STAGE_SOLVING
661  * - \ref SCIP_STAGE_SOLVED
662  */
664  SCIP* scip /**< SCIP data structure */
665  )
666 {
667  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNPrimalResolveLPs", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
668 
669  return scip->stat->nprimalresolvelps;
670 }
671 
672 /** gets total number of simplex iterations used so far in primal simplex calls where an advanced start basis
673  * was available
674  *
675  * @return the total number of simplex iterations used so far in primal simplex calls where an advanced start
676  * basis was available
677  *
678  * @pre This method can be called if SCIP is in one of the following stages:
679  * - \ref SCIP_STAGE_PRESOLVED
680  * - \ref SCIP_STAGE_SOLVING
681  * - \ref SCIP_STAGE_SOLVED
682  */
684  SCIP* scip /**< SCIP data structure */
685  )
686 {
687  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNPrimalResolveLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
688 
689  return scip->stat->nprimalresolvelpiterations;
690 }
691 
692 /** gets total number of dual LPs solved so far that were resolved from an advanced start basis
693  *
694  * @return the total number of dual LPs solved so far that were resolved from an advanced start basis
695  *
696  * @pre This method can be called if SCIP is in one of the following stages:
697  * - \ref SCIP_STAGE_PRESOLVED
698  * - \ref SCIP_STAGE_SOLVING
699  * - \ref SCIP_STAGE_SOLVED
700  */
702  SCIP* scip /**< SCIP data structure */
703  )
704 {
705  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNDualResolveLPs", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
706 
707  return scip->stat->ndualresolvelps;
708 }
709 
710 /** gets total number of simplex iterations used so far in dual simplex calls where an advanced start basis
711  * was available
712  *
713  * @return the total number of simplex iterations used so far in dual simplex calls where an advanced start
714  * basis was available
715  *
716  * @pre This method can be called if SCIP is in one of the following stages:
717  * - \ref SCIP_STAGE_PRESOLVED
718  * - \ref SCIP_STAGE_SOLVING
719  * - \ref SCIP_STAGE_SOLVED
720  */
722  SCIP* scip /**< SCIP data structure */
723  )
724 {
725  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNDualResolveLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
726 
727  return scip->stat->ndualresolvelpiterations;
728 }
729 
730 /** gets total number of LPs solved so far for node relaxations
731  *
732  * @return the total number of LPs solved so far for node relaxations
733  *
734  * @pre This method can be called if SCIP is in one of the following stages:
735  * - \ref SCIP_STAGE_PRESOLVED
736  * - \ref SCIP_STAGE_SOLVING
737  * - \ref SCIP_STAGE_SOLVED
738  */
740  SCIP* scip /**< SCIP data structure */
741  )
742 {
743  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNNodeLPs", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
744 
745  return scip->stat->nnodelps;
746 }
747 
748 /** gets total number of simplex iterations used so far for node relaxations
749  *
750  * @return the total number of simplex iterations used so far for node relaxations
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  */
758  SCIP* scip /**< SCIP data structure */
759  )
760 {
761  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNNodeLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
762 
763  return scip->stat->nnodelpiterations;
764 }
765 
766 /** gets total number of LPs solved so far for initial LP in node relaxations
767  *
768  * @return the total number of LPs solved so far for initial LP in node relaxations
769  *
770  * @pre This method can be called if SCIP is in one of the following stages:
771  * - \ref SCIP_STAGE_PRESOLVED
772  * - \ref SCIP_STAGE_SOLVING
773  * - \ref SCIP_STAGE_SOLVED
774  */
776  SCIP* scip /**< SCIP data structure */
777  )
778 {
779  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNNodeInitLPs", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
780 
781  return scip->stat->ninitlps;
782 }
783 
784 /** gets total number of simplex iterations used so far for initial LP in node relaxations
785  *
786  * @return the total number of simplex iterations used so far for initial LP in node relaxations
787  *
788  * @pre This method can be called if SCIP is in one of the following stages:
789  * - \ref SCIP_STAGE_PRESOLVED
790  * - \ref SCIP_STAGE_SOLVING
791  * - \ref SCIP_STAGE_SOLVED
792  */
794  SCIP* scip /**< SCIP data structure */
795  )
796 {
797  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNNodeInitLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
798 
799  return scip->stat->ninitlpiterations;
800 }
801 
802 /** gets total number of LPs solved so far during diving and probing
803  *
804  * @return total number of LPs solved so far during diving and probing
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  */
812  SCIP* scip /**< SCIP data structure */
813  )
814 {
815  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNDivingLPs", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
816 
817  return scip->stat->ndivinglps;
818 }
819 
820 /** gets total number of simplex iterations used so far during diving and probing
821  *
822  * @return the total number of simplex iterations used so far during diving and probing
823  *
824  * @pre This method can be called if SCIP is in one of the following stages:
825  * - \ref SCIP_STAGE_PRESOLVED
826  * - \ref SCIP_STAGE_SOLVING
827  * - \ref SCIP_STAGE_SOLVED
828  */
830  SCIP* scip /**< SCIP data structure */
831  )
832 {
833  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNDivingLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
834 
835  return scip->stat->ndivinglpiterations;
836 }
837 
838 /** gets total number of times, strong branching was called (each call represents solving two LPs)
839  *
840  * @return the total number of times, strong branching was called (each call represents solving two LPs)
841  *
842  * @pre This method can be called if SCIP is in one of the following stages:
843  * - \ref SCIP_STAGE_PRESOLVED
844  * - \ref SCIP_STAGE_SOLVING
845  * - \ref SCIP_STAGE_SOLVED
846  */
848  SCIP* scip /**< SCIP data structure */
849  )
850 {
851  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNStrongbranchs", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
852 
853  return scip->stat->nstrongbranchs;
854 }
855 
856 /** gets total number of simplex iterations used so far in strong branching
857  *
858  * @return the total number of simplex iterations used so far in strong branching
859  *
860  * @pre This method can be called if SCIP is in one of the following stages:
861  * - \ref SCIP_STAGE_PRESOLVED
862  * - \ref SCIP_STAGE_SOLVING
863  * - \ref SCIP_STAGE_SOLVED
864  */
866  SCIP* scip /**< SCIP data structure */
867  )
868 {
869  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNStrongbranchLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
870 
871  return scip->stat->nsblpiterations;
872 }
873 
874 /** gets total number of times, strong branching was called at the root node (each call represents solving two LPs)
875  *
876  * @return the total number of times, strong branching was called at the root node (each call represents solving two LPs)
877  *
878  * @pre This method can be called if SCIP is in one of the following stages:
879  * - \ref SCIP_STAGE_PRESOLVED
880  * - \ref SCIP_STAGE_SOLVING
881  * - \ref SCIP_STAGE_SOLVED
882  */
884  SCIP* scip /**< SCIP data structure */
885  )
886 {
887  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNRootStrongbranchs", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
888 
889  return scip->stat->nrootstrongbranchs;
890 }
891 
892 /** gets total number of simplex iterations used so far in strong branching at the root node
893  *
894  * @return the total number of simplex iterations used so far in strong branching at the root node
895  *
896  * @pre This method can be called if SCIP is in one of the following stages:
897  * - \ref SCIP_STAGE_PRESOLVED
898  * - \ref SCIP_STAGE_SOLVING
899  * - \ref SCIP_STAGE_SOLVED
900  */
902  SCIP* scip /**< SCIP data structure */
903  )
904 {
905  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNRootStrongbranchLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
906 
907  return scip->stat->nrootsblpiterations;
908 }
909 
910 /** gets number of pricing rounds performed so far at the current node
911  *
912  * @return the number of pricing rounds performed so far at the current node
913  *
914  * @pre This method can be called if SCIP is in one of the following stages:
915  * - \ref SCIP_STAGE_SOLVING
916  */
918  SCIP* scip /**< SCIP data structure */
919  )
920 {
921  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNPriceRounds", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
922 
923  return scip->stat->npricerounds;
924 }
925 
926 /** get current number of variables in the pricing store
927  *
928  * @return the current number of variables in the pricing store
929  *
930  * @pre This method can be called if SCIP is in one of the following stages:
931  * - \ref SCIP_STAGE_PRESOLVED
932  * - \ref SCIP_STAGE_SOLVING
933  * - \ref SCIP_STAGE_SOLVED
934  */
936  SCIP* scip /**< SCIP data structure */
937  )
938 {
939  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNPricevars", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
940 
941  return SCIPpricestoreGetNVars(scip->pricestore);
942 }
943 
944 /** get total number of pricing variables found so far
945  *
946  * @return the total number of pricing variables found so far
947  *
948  * @pre This method can be called if SCIP is in one of the following stages:
949  * - \ref SCIP_STAGE_PRESOLVED
950  * - \ref SCIP_STAGE_SOLVING
951  * - \ref SCIP_STAGE_SOLVED
952  */
954  SCIP* scip /**< SCIP data structure */
955  )
956 {
957  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNPricevarsFound", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
958 
960 }
961 
962 /** get total number of pricing variables applied to the LPs
963  *
964  * @return the total number of pricing variables applied to the LPs
965  *
966  * @pre This method can be called if SCIP is in one of the following stages:
967  * - \ref SCIP_STAGE_PRESOLVED
968  * - \ref SCIP_STAGE_SOLVING
969  * - \ref SCIP_STAGE_SOLVED
970  */
972  SCIP* scip /**< SCIP data structure */
973  )
974 {
975  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNPricevarsApplied", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
976 
978 }
979 
980 /** gets number of separation rounds performed so far at the current node
981  *
982  * @return the number of separation rounds performed so far at the current node
983  *
984  * @pre This method can be called if SCIP is in one of the following stages:
985  * - \ref SCIP_STAGE_SOLVING
986  */
988  SCIP* scip /**< SCIP data structure */
989  )
990 {
991  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNSepaRounds", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
992 
993  return scip->stat->nseparounds;
994 }
995 
996 /** get total number of cuts found so far
997  *
998  * @return the total number of cuts found so far
999  *
1000  * @pre This method can be called if SCIP is in one of the following stages:
1001  * - \ref SCIP_STAGE_PRESOLVED
1002  * - \ref SCIP_STAGE_SOLVING
1003  * - \ref SCIP_STAGE_SOLVED
1004  */
1006  SCIP* scip /**< SCIP data structure */
1007  )
1008 {
1009  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNCutsFound", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1010 
1011  return SCIPsepastoreGetNCutsFound(scip->sepastore);
1012 }
1013 
1014 /** get number of cuts found so far in current separation round
1015  *
1016  * @return the number of cuts found so far in current separation round
1017  *
1018  * @pre This method can be called if SCIP is in one of the following stages:
1019  * - \ref SCIP_STAGE_PRESOLVED
1020  * - \ref SCIP_STAGE_SOLVING
1021  * - \ref SCIP_STAGE_SOLVED
1022  */
1024  SCIP* scip /**< SCIP data structure */
1025  )
1026 {
1027  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNCutsFoundRound", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1028 
1030 }
1031 
1032 /** get total number of cuts applied to the LPs
1033  *
1034  * @return the total number of cuts applied to the LPs
1035  *
1036  * @pre This method can be called if SCIP is in one of the following stages:
1037  * - \ref SCIP_STAGE_PRESOLVED
1038  * - \ref SCIP_STAGE_SOLVING
1039  * - \ref SCIP_STAGE_SOLVED
1040  */
1042  SCIP* scip /**< SCIP data structure */
1043  )
1044 {
1045  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNCutsApplied", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1046 
1048 }
1049 
1050 /** get total number of constraints found in conflict analysis (conflict, reconvergence constraints, and dual proofs)
1051  *
1052  * @return the total number of constraints found in conflict analysis (conflict, reconvergence constraints, and dual proofs)
1053  *
1054  * @pre This method can be called if SCIP is in one of the following stages:
1055  * - \ref SCIP_STAGE_TRANSFORMED
1056  * - \ref SCIP_STAGE_INITPRESOLVE
1057  * - \ref SCIP_STAGE_PRESOLVING
1058  * - \ref SCIP_STAGE_EXITPRESOLVE
1059  * - \ref SCIP_STAGE_PRESOLVED
1060  * - \ref SCIP_STAGE_INITSOLVE
1061  * - \ref SCIP_STAGE_SOLVING
1062  * - \ref SCIP_STAGE_SOLVED
1063  * - \ref SCIP_STAGE_EXITSOLVE
1064  */
1066  SCIP* scip /**< SCIP data structure */
1067  )
1068 {
1069  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNConflictConssFound", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1070 
1083 }
1084 
1085 /** get number of conflict constraints found so far at the current node
1086  *
1087  * @return the number of conflict constraints found so far at the current node
1088  *
1089  * @pre This method can be called if SCIP is in one of the following stages:
1090  * - \ref SCIP_STAGE_TRANSFORMED
1091  * - \ref SCIP_STAGE_INITPRESOLVE
1092  * - \ref SCIP_STAGE_PRESOLVING
1093  * - \ref SCIP_STAGE_EXITPRESOLVE
1094  * - \ref SCIP_STAGE_PRESOLVED
1095  * - \ref SCIP_STAGE_INITSOLVE
1096  * - \ref SCIP_STAGE_SOLVING
1097  * - \ref SCIP_STAGE_SOLVED
1098  * - \ref SCIP_STAGE_EXITSOLVE
1099  */
1101  SCIP* scip /**< SCIP data structure */
1102  )
1103 {
1104  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNConflictConssFoundNode", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1105 
1106  return SCIPconflictGetNConflicts(scip->conflict);
1107 }
1108 
1109 /** get total number of conflict constraints added to the problem
1110  *
1111  * @return the total number of conflict constraints added to the problem
1112  *
1113  * @pre This method can be called if SCIP is in one of the following stages:
1114  * - \ref SCIP_STAGE_TRANSFORMED
1115  * - \ref SCIP_STAGE_INITPRESOLVE
1116  * - \ref SCIP_STAGE_PRESOLVING
1117  * - \ref SCIP_STAGE_EXITPRESOLVE
1118  * - \ref SCIP_STAGE_PRESOLVED
1119  * - \ref SCIP_STAGE_INITSOLVE
1120  * - \ref SCIP_STAGE_SOLVING
1121  * - \ref SCIP_STAGE_SOLVED
1122  * - \ref SCIP_STAGE_EXITSOLVE
1123  */
1125  SCIP* scip /**< SCIP data structure */
1126  )
1127 {
1128  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNConflictConssApplied", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1129 
1130  return SCIPconflictGetNAppliedConss(scip->conflict);
1131 }
1132 
1133 /** gets maximal depth of all processed nodes in current branch and bound run (excluding probing nodes)
1134  *
1135  * @return the maximal depth of all processed nodes in current branch and bound run (excluding probing nodes)
1136  *
1137  * @pre This method can be called if SCIP is in one of the following stages:
1138  * - \ref SCIP_STAGE_TRANSFORMED
1139  * - \ref SCIP_STAGE_INITPRESOLVE
1140  * - \ref SCIP_STAGE_PRESOLVING
1141  * - \ref SCIP_STAGE_EXITPRESOLVE
1142  * - \ref SCIP_STAGE_PRESOLVED
1143  * - \ref SCIP_STAGE_INITSOLVE
1144  * - \ref SCIP_STAGE_SOLVING
1145  * - \ref SCIP_STAGE_SOLVED
1146  * - \ref SCIP_STAGE_EXITSOLVE
1147  */
1149  SCIP* scip /**< SCIP data structure */
1150  )
1151 {
1152  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetMaxDepth", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1153 
1154  return scip->stat->maxdepth;
1155 }
1156 
1157 /** gets maximal depth of all processed nodes over all branch and bound runs
1158  *
1159  * @return the maximal depth of all processed nodes over all branch and bound runs
1160  *
1161  * @pre This method can be called if SCIP is in one of the following stages:
1162  * - \ref SCIP_STAGE_TRANSFORMED
1163  * - \ref SCIP_STAGE_INITPRESOLVE
1164  * - \ref SCIP_STAGE_PRESOLVING
1165  * - \ref SCIP_STAGE_EXITPRESOLVE
1166  * - \ref SCIP_STAGE_PRESOLVED
1167  * - \ref SCIP_STAGE_INITSOLVE
1168  * - \ref SCIP_STAGE_SOLVING
1169  * - \ref SCIP_STAGE_SOLVED
1170  * - \ref SCIP_STAGE_EXITSOLVE
1171  */
1173  SCIP* scip /**< SCIP data structure */
1174  )
1175 {
1176  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetMaxTotalDepth", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1177 
1178  return scip->stat->maxtotaldepth;
1179 }
1180 
1181 /** gets total number of backtracks, i.e. number of times, the new node was selected from the leaves queue
1182  *
1183  * @return the total number of backtracks, i.e. number of times, the new node was selected from the leaves queue
1184  *
1185  * @pre This method can be called if SCIP is in one of the following stages:
1186  * - \ref SCIP_STAGE_TRANSFORMED
1187  * - \ref SCIP_STAGE_INITPRESOLVE
1188  * - \ref SCIP_STAGE_PRESOLVING
1189  * - \ref SCIP_STAGE_EXITPRESOLVE
1190  * - \ref SCIP_STAGE_PRESOLVED
1191  * - \ref SCIP_STAGE_INITSOLVE
1192  * - \ref SCIP_STAGE_SOLVING
1193  * - \ref SCIP_STAGE_SOLVED
1194  * - \ref SCIP_STAGE_EXITSOLVE
1195  */
1197  SCIP* scip /**< SCIP data structure */
1198  )
1199 {
1200  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNBacktracks", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1201 
1202  return scip->stat->nbacktracks;
1203 }
1204 
1205 /** gets total number of active constraints at the current node
1206  *
1207  * @return the total number of active constraints at the current node
1208  *
1209  * @pre This method can be called if SCIP is in one of the following stages:
1210  * - \ref SCIP_STAGE_INITPRESOLVE
1211  * - \ref SCIP_STAGE_PRESOLVING
1212  * - \ref SCIP_STAGE_EXITPRESOLVE
1213  * - \ref SCIP_STAGE_PRESOLVED
1214  * - \ref SCIP_STAGE_SOLVING
1215  */
1217  SCIP* scip /**< SCIP data structure */
1218  )
1219 {
1220  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNActiveConss", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1221 
1222  return scip->stat->nactiveconss;
1223 }
1224 
1225 /** gets total number of enabled constraints at the current node
1226  *
1227  * @return the total number of enabled constraints at the current node
1228  *
1229  * @pre This method can be called if SCIP is in one of the following stages:
1230  * - \ref SCIP_STAGE_PRESOLVED
1231  * - \ref SCIP_STAGE_SOLVING
1232  */
1234  SCIP* scip /**< SCIP data structure */
1235  )
1236 {
1237  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNEnabledConss", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1238 
1239  return scip->stat->nenabledconss;
1240 }
1241 
1242 /** gets average dual bound of all unprocessed nodes for original problem
1243  *
1244  * @return the average dual bound of all unprocessed nodes for original problem
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  */
1252  SCIP* scip /**< SCIP data structure */
1253  )
1254 {
1255  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgDualbound", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1256 
1257  return SCIPprobExternObjval(scip->transprob, scip->origprob, scip->set,
1259 }
1260 
1261 /** gets average lower (dual) bound of all unprocessed nodes in transformed problem
1262  *
1263  * @return the average lower (dual) bound of all unprocessed nodes in transformed problem
1264  *
1265  * @pre This method can be called if SCIP is in one of the following stages:
1266  * - \ref SCIP_STAGE_PRESOLVED
1267  * - \ref SCIP_STAGE_SOLVING
1268  * - \ref SCIP_STAGE_SOLVED
1269  */
1271  SCIP* scip /**< SCIP data structure */
1272  )
1273 {
1274  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgLowerbound", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1275 
1276  return SCIPtreeGetAvgLowerbound(scip->tree, scip->primal->cutoffbound);
1277 }
1278 
1279 /** gets global dual bound
1280  *
1281  * @return the global dual bound
1282  *
1283  * @pre This method can be called if SCIP is in one of the following stages:
1284  * - \ref SCIP_STAGE_TRANSFORMED
1285  * - \ref SCIP_STAGE_INITPRESOLVE
1286  * - \ref SCIP_STAGE_PRESOLVING
1287  * - \ref SCIP_STAGE_EXITPRESOLVE
1288  * - \ref SCIP_STAGE_PRESOLVED
1289  * - \ref SCIP_STAGE_INITSOLVE
1290  * - \ref SCIP_STAGE_SOLVING
1291  * - \ref SCIP_STAGE_SOLVED
1292  * - \ref SCIP_STAGE_EXITSOLVE
1293  */
1295  SCIP* scip /**< SCIP data structure */
1296  )
1297 {
1298  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetDualbound", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1299 
1300  /* in case we are in presolving we use the stored dual bound if it exits */
1301  if( scip->set->stage <= SCIP_STAGE_INITSOLVE && scip->transprob->dualbound < SCIP_INVALID )
1302  return scip->transprob->dualbound;
1303 
1304  return SCIPprobExternObjval(scip->transprob, scip->origprob, scip->set, SCIPgetLowerbound(scip));
1305 }
1306 
1307 /** gets global lower (dual) bound in transformed problem
1308  *
1309  * @return the global lower (dual) bound in transformed problem
1310  *
1311  * @pre This method can be called if SCIP is in one of the following stages:
1312  * - \ref SCIP_STAGE_TRANSFORMED
1313  * - \ref SCIP_STAGE_INITPRESOLVE
1314  * - \ref SCIP_STAGE_PRESOLVING
1315  * - \ref SCIP_STAGE_EXITPRESOLVE
1316  * - \ref SCIP_STAGE_PRESOLVED
1317  * - \ref SCIP_STAGE_INITSOLVE
1318  * - \ref SCIP_STAGE_SOLVING
1319  * - \ref SCIP_STAGE_SOLVED
1320  */
1322  SCIP* scip /**< SCIP data structure */
1323  )
1324 {
1325  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetLowerbound", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1326 
1327  if( scip->set->stage <= SCIP_STAGE_INITSOLVE )
1328  return -SCIPinfinity(scip);
1330  {
1331  /* in case we could not prove whether the problem is unbounded or infeasible, we want to terminate with lower
1332  * bound = -inf instead of lower bound = upper bound = +inf also in case we prove that the problem is unbounded,
1333  * it seems to make sense to return with lower bound = -inf, since -infinity is the only valid lower bound
1334  */
1335  return -SCIPinfinity(scip);
1336  }
1337  else
1338  {
1339  SCIP_Real treelowerbound;
1340 
1341  /* it may happen that the remaining tree is empty or all open nodes have a lower bound above the cutoff bound, but
1342  * have not yet been cut off, e.g., when the user calls SCIPgetDualbound() in some event handler; in this case,
1343  * the global lower bound is given by the upper bound value
1344  */
1345  treelowerbound = SCIPtreeGetLowerbound(scip->tree, scip->set);
1346 
1347  if( treelowerbound < scip->primal->upperbound)
1348  return treelowerbound;
1349  else
1350  return scip->primal->upperbound;
1351  }
1352 }
1353 
1354 /** gets dual bound of the root node for the original problem
1355  *
1356  * @return the dual bound of the root node for the original problem
1357  *
1358  * @pre This method can be called if SCIP is in one of the following stages:
1359  * - \ref SCIP_STAGE_PRESOLVING
1360  * - \ref SCIP_STAGE_EXITPRESOLVE
1361  * - \ref SCIP_STAGE_PRESOLVED
1362  * - \ref SCIP_STAGE_INITSOLVE
1363  * - \ref SCIP_STAGE_SOLVING
1364  * - \ref SCIP_STAGE_SOLVED
1365  */
1367  SCIP* scip /**< SCIP data structure */
1368  )
1369 {
1370  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetDualboundRoot", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1371 
1372  if( SCIPsetIsInfinity(scip->set, scip->stat->rootlowerbound) )
1373  return SCIPgetPrimalbound(scip);
1374  else
1375  return SCIPprobExternObjval(scip->transprob, scip->origprob, scip->set, scip->stat->rootlowerbound);
1376 }
1377 
1378 /** gets lower (dual) bound in transformed problem of the root node
1379  *
1380  * @return the lower (dual) bound in transformed problem of the root node
1381  *
1382  * @pre This method can be called if SCIP is in one of the following stages:
1383  * - \ref SCIP_STAGE_PRESOLVING
1384  * - \ref SCIP_STAGE_EXITPRESOLVE
1385  * - \ref SCIP_STAGE_PRESOLVED
1386  * - \ref SCIP_STAGE_INITSOLVE
1387  * - \ref SCIP_STAGE_SOLVING
1388  * - \ref SCIP_STAGE_SOLVED
1389  */
1391  SCIP* scip /**< SCIP data structure */
1392  )
1393 {
1394  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetLowerboundRoot", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1395 
1396  if( SCIPsetIsInfinity(scip->set, scip->stat->rootlowerbound) )
1397  return SCIPgetUpperbound(scip);
1398  else
1399  return scip->stat->rootlowerbound;
1400 }
1401 
1402 /** gets dual bound for the original problem obtained by the first LP solve at the root node
1403  *
1404  * @return the dual bound for the original problem of the first LP solve at the root node
1405  *
1406  * @pre This method can be called if SCIP is in one of the following stages:
1407  * - \ref SCIP_STAGE_PRESOLVING
1408  * - \ref SCIP_STAGE_EXITPRESOLVE
1409  * - \ref SCIP_STAGE_PRESOLVED
1410  * - \ref SCIP_STAGE_INITSOLVE
1411  * - \ref SCIP_STAGE_SOLVING
1412  * - \ref SCIP_STAGE_SOLVED
1413  */
1415  SCIP* scip /**< SCIP data structure */
1416  )
1417 {
1418  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetFirstLPDualboundRoot", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1419 
1420  return scip->stat->firstlpdualbound;
1421 }
1422 
1423 /** gets lower (dual) bound in transformed problem obtained by the first LP solve at the root node
1424  *
1425  * @return the lower (dual) bound in transformed problem obtained by first LP solve at the root node
1426  *
1427  * @pre This method can be called if SCIP is in one of the following stages:
1428  * - \ref SCIP_STAGE_PRESOLVING
1429  * - \ref SCIP_STAGE_EXITPRESOLVE
1430  * - \ref SCIP_STAGE_PRESOLVED
1431  * - \ref SCIP_STAGE_INITSOLVE
1432  * - \ref SCIP_STAGE_SOLVING
1433  * - \ref SCIP_STAGE_SOLVED
1434  */
1436  SCIP* scip /**< SCIP data structure */
1437  )
1438 {
1439  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetFirstLPLowerboundRoot", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1440 
1441  if( scip->stat->firstlpdualbound == SCIP_INVALID ) /*lint !e777*/
1442  return -SCIPinfinity(scip);
1443  else
1444  return SCIPprobInternObjval(scip->transprob, scip->origprob, scip->set, scip->stat->firstlpdualbound);
1445 }
1446 
1447 /** the primal bound of the very first solution */
1449  SCIP* scip /**< SCIP data structure */
1450  )
1451 {
1452  return scip->stat->firstprimalbound;
1453 }
1454 
1455 /** gets global primal bound (objective value of best solution or user objective limit) for the original problem
1456  *
1457  * @return the global primal bound (objective value of best solution or user objective limit) for the original problem
1458  *
1459  * @pre This method can be called if SCIP is in one of the following stages:
1460  * - \ref SCIP_STAGE_TRANSFORMED
1461  * - \ref SCIP_STAGE_INITPRESOLVE
1462  * - \ref SCIP_STAGE_PRESOLVING
1463  * - \ref SCIP_STAGE_EXITPRESOLVE
1464  * - \ref SCIP_STAGE_PRESOLVED
1465  * - \ref SCIP_STAGE_INITSOLVE
1466  * - \ref SCIP_STAGE_SOLVING
1467  * - \ref SCIP_STAGE_SOLVED
1468  * - \ref SCIP_STAGE_EXITSOLVE
1469  */
1471  SCIP* scip /**< SCIP data structure */
1472  )
1473 {
1474  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetPrimalbound", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1475 
1476  return SCIPprobExternObjval(scip->transprob, scip->origprob, scip->set, SCIPgetUpperbound(scip));
1477 }
1478 
1479 /** gets global upper (primal) bound in transformed problem (objective value of best solution or user objective limit)
1480  *
1481  * @return the global upper (primal) bound in transformed problem (objective value of best solution or user objective limit)
1482  *
1483  * @pre This method can be called if SCIP is in one of the following stages:
1484  * - \ref SCIP_STAGE_TRANSFORMED
1485  * - \ref SCIP_STAGE_INITPRESOLVE
1486  * - \ref SCIP_STAGE_PRESOLVING
1487  * - \ref SCIP_STAGE_EXITPRESOLVE
1488  * - \ref SCIP_STAGE_PRESOLVED
1489  * - \ref SCIP_STAGE_INITSOLVE
1490  * - \ref SCIP_STAGE_SOLVING
1491  * - \ref SCIP_STAGE_SOLVED
1492  * - \ref SCIP_STAGE_EXITSOLVE
1493  */
1495  SCIP* scip /**< SCIP data structure */
1496  )
1497 {
1498  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetUpperbound", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1499 
1500  if( SCIPgetStatus(scip) == SCIP_STATUS_UNBOUNDED )
1501  return -SCIPinfinity(scip);
1502  else
1503  return scip->primal->upperbound;
1504 }
1505 
1506 /** gets global cutoff bound in transformed problem: a sub problem with lower bound larger than the cutoff
1507  * cannot contain a better feasible solution; usually, this bound is equal to the upper bound, but if the
1508  * objective value is always integral, the cutoff bound is (nearly) one less than the upper bound;
1509  * additionally, due to objective function domain propagation, the cutoff bound can be further reduced
1510  *
1511  * @return global cutoff bound in transformed problem
1512  *
1513  * @pre This method can be called if SCIP is in one of the following stages:
1514  * - \ref SCIP_STAGE_TRANSFORMED
1515  * - \ref SCIP_STAGE_INITPRESOLVE
1516  * - \ref SCIP_STAGE_PRESOLVING
1517  * - \ref SCIP_STAGE_EXITPRESOLVE
1518  * - \ref SCIP_STAGE_PRESOLVED
1519  * - \ref SCIP_STAGE_INITSOLVE
1520  * - \ref SCIP_STAGE_SOLVING
1521  * - \ref SCIP_STAGE_SOLVED
1522  * - \ref SCIP_STAGE_EXITSOLVE
1523  */
1525  SCIP* scip /**< SCIP data structure */
1526  )
1527 {
1528  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetCutoffbound", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1529 
1530  return scip->primal->cutoffbound;
1531 }
1532 
1533 /** updates the cutoff bound
1534  *
1535  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1536  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1537  *
1538  * @note using this method in the solving stage can lead to an erroneous SCIP solving status; in particular,
1539  * if a solution not respecting the cutoff bound was found before installing a cutoff bound which
1540  * renders the remaining problem infeasible, this solution may be reported as optimal
1541  *
1542  * @pre This method can be called if SCIP is in one of the following stages:
1543  * - \ref SCIP_STAGE_TRANSFORMED
1544  * - \ref SCIP_STAGE_PRESOLVING
1545  * - \ref SCIP_STAGE_PRESOLVED
1546  * - \ref SCIP_STAGE_INITSOLVE
1547  * - \ref SCIP_STAGE_SOLVING
1548  *
1549  * @note the given cutoff bound has to better or equal to known one (SCIPgetCutoffbound())
1550  * @note a given cutoff bound is also used for updating the objective limit, if possible
1551  */
1553  SCIP* scip, /**< SCIP data structure */
1554  SCIP_Real cutoffbound /**< new cutoff bound */
1555  )
1556 {
1557  SCIP_CALL( SCIPcheckStage(scip, "SCIPupdateCutoffbound", FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1558 
1559  assert(cutoffbound <= SCIPgetCutoffbound(scip));
1560 
1561  SCIP_CALL( SCIPprimalSetCutoffbound(scip->primal, scip->mem->probmem, scip->set, scip->stat, scip->eventqueue,
1562  scip->transprob, scip->origprob, scip->tree, scip->reopt, scip->lp, cutoffbound, FALSE) );
1563 
1564  return SCIP_OKAY;
1565 }
1566 
1567 
1568 /** returns whether the current primal bound is justified with a feasible primal solution; if not, the primal bound
1569  * was set from the user as objective limit
1570  *
1571  * @return TRUE if the current primal bound is justified with a feasible primal solution, otherwise FALSE
1572  *
1573  * @pre This method can be called if SCIP is in one of the following stages:
1574  * - \ref SCIP_STAGE_TRANSFORMED
1575  * - \ref SCIP_STAGE_INITPRESOLVE
1576  * - \ref SCIP_STAGE_PRESOLVING
1577  * - \ref SCIP_STAGE_EXITPRESOLVE
1578  * - \ref SCIP_STAGE_PRESOLVED
1579  * - \ref SCIP_STAGE_INITSOLVE
1580  * - \ref SCIP_STAGE_SOLVING
1581  * - \ref SCIP_STAGE_SOLVED
1582  * - \ref SCIP_STAGE_EXITSOLVE
1583  */
1585  SCIP* scip /**< SCIP data structure */
1586  )
1587 {
1588  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPisPrimalboundSol", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1589 
1590  return SCIPprimalUpperboundIsSol(scip->primal, scip->set, scip->transprob, scip->origprob);
1591 }
1592 
1593 /** gets current gap |(primalbound - dualbound)/min(|primalbound|,|dualbound|)| if both bounds have same sign,
1594  * or infinity, if they have opposite sign
1595  *
1596  * @return the current gap |(primalbound - dualbound)/min(|primalbound|,|dualbound|)| if both bounds have same sign,
1597  * or infinity, if they have opposite sign
1598  *
1599  * @pre This method can be called if SCIP is in one of the following stages:
1600  * - \ref SCIP_STAGE_PRESOLVING
1601  * - \ref SCIP_STAGE_EXITPRESOLVE
1602  * - \ref SCIP_STAGE_PRESOLVED
1603  * - \ref SCIP_STAGE_INITSOLVE
1604  * - \ref SCIP_STAGE_SOLVING
1605  * - \ref SCIP_STAGE_SOLVED
1606  */
1608  SCIP* scip /**< SCIP data structure */
1609  )
1610 {
1612 
1613  /* in case we could not prove whether the problem is unbounded or infeasible, we want to terminate with gap = +inf;
1614  * if the problem was proven to be unbounded or proven to be infeasible we return gap = 0
1615  */
1616  if( SCIPgetStatus(scip) == SCIP_STATUS_INFORUNBD )
1617  return SCIPsetInfinity(scip->set);
1619  return 0.0;
1620 
1621  /* the lowerbound is infinity, but SCIP may not have updated the status; in this case, the problem was already solved
1622  * so we return gap = 0
1623  */
1624  if( SCIPsetIsInfinity(scip->set, SCIPgetLowerbound(scip)) )
1625  return 0.0;
1626 
1628 }
1629 
1630 /** gets current gap |(upperbound - lowerbound)/min(|upperbound|,|lowerbound|)| in transformed problem if both bounds
1631  * have same sign, or infinity, if they have opposite sign
1632  *
1633  * @return current gap |(upperbound - lowerbound)/min(|upperbound|,|lowerbound|)| in transformed problem if both bounds
1634  * have same sign, or infinity, if they have opposite sign
1635  *
1636  * @pre This method can be called if SCIP is in one of the following stages:
1637  * - \ref SCIP_STAGE_PRESOLVED
1638  * - \ref SCIP_STAGE_SOLVING
1639  * - \ref SCIP_STAGE_SOLVED
1640  */
1642  SCIP* scip /**< SCIP data structure */
1643  )
1644 {
1645  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetTransGap", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1646 
1647  /* in case we could not prove whether the problem is unbounded or infeasible, we want to terminate with gap = +inf;
1648  * if the problem was proven to be unbounded or proven to be infeasible we return gap = 0
1649  */
1650  if( SCIPgetStatus(scip) == SCIP_STATUS_INFORUNBD )
1651  return SCIPsetInfinity(scip->set);
1653  return 0.0;
1654 
1655  /* the lowerbound is infinity, but SCIP may not have updated the status; in this case, the problem was already solved
1656  * so we return gap = 0
1657  */
1658  if( SCIPsetIsInfinity(scip->set, SCIPgetLowerbound(scip)) )
1659  return 0.0;
1660 
1662 }
1663 
1664 /** gets number of feasible primal solutions found so far
1665  *
1666  * @return the number of feasible primal solutions found so far
1667  *
1668  * @pre This method can be called if SCIP is in one of the following stages:
1669  * - \ref SCIP_STAGE_TRANSFORMED
1670  * - \ref SCIP_STAGE_INITPRESOLVE
1671  * - \ref SCIP_STAGE_PRESOLVING
1672  * - \ref SCIP_STAGE_EXITPRESOLVE
1673  * - \ref SCIP_STAGE_PRESOLVED
1674  * - \ref SCIP_STAGE_INITSOLVE
1675  * - \ref SCIP_STAGE_SOLVING
1676  * - \ref SCIP_STAGE_SOLVED
1677  * - \ref SCIP_STAGE_EXITSOLVE
1678  */
1680  SCIP* scip /**< SCIP data structure */
1681  )
1682 {
1683  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNSolsFound", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1684 
1685  return scip->primal->nsolsfound;
1686 }
1687 
1688 /** gets number of feasible primal solutions respecting the objective limit found so far
1689  *
1690  * @return the number of feasible primal solutions respecting the objective limit found so far
1691  *
1692  * @pre This method can be called if SCIP is in one of the following stages:
1693  * - \ref SCIP_STAGE_INIT
1694  * - \ref SCIP_STAGE_PROBLEM
1695  * - \ref SCIP_STAGE_TRANSFORMING
1696  * - \ref SCIP_STAGE_TRANSFORMED
1697  * - \ref SCIP_STAGE_INITPRESOLVE
1698  * - \ref SCIP_STAGE_PRESOLVING
1699  * - \ref SCIP_STAGE_EXITPRESOLVE
1700  * - \ref SCIP_STAGE_PRESOLVED
1701  * - \ref SCIP_STAGE_INITSOLVE
1702  * - \ref SCIP_STAGE_SOLVING
1703  * - \ref SCIP_STAGE_SOLVED
1704  * - \ref SCIP_STAGE_EXITSOLVE
1705  */
1707  SCIP* scip /**< SCIP data structure */
1708  )
1709 {
1711  return 0;
1712 
1713  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNLimSolsFound", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1714 
1715  return scip->primal->nlimsolsfound;
1716 }
1717 
1718 /** gets number of feasible primal solutions found so far, that improved the primal bound at the time they were found
1719  *
1720  * @return the number of feasible primal solutions found so far, that improved the primal bound at the time they were found
1721  *
1722  * @pre This method can be called if SCIP is in one of the following stages:
1723  * - \ref SCIP_STAGE_TRANSFORMED
1724  * - \ref SCIP_STAGE_INITPRESOLVE
1725  * - \ref SCIP_STAGE_PRESOLVING
1726  * - \ref SCIP_STAGE_EXITPRESOLVE
1727  * - \ref SCIP_STAGE_PRESOLVED
1728  * - \ref SCIP_STAGE_INITSOLVE
1729  * - \ref SCIP_STAGE_SOLVING
1730  * - \ref SCIP_STAGE_SOLVED
1731  * - \ref SCIP_STAGE_EXITSOLVE
1732  */
1734  SCIP* scip /**< SCIP data structure */
1735  )
1736 {
1737  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNBestSolsFound", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1738 
1739  return scip->primal->nbestsolsfound;
1740 }
1741 
1742 /** gets the average pseudo cost value for the given direction over all variables
1743  *
1744  * @return the average pseudo cost value for the given direction over all variables
1745  *
1746  * @pre This method can be called if SCIP is in one of the following stages:
1747  * - \ref SCIP_STAGE_SOLVING
1748  * - \ref SCIP_STAGE_SOLVED
1749  */
1751  SCIP* scip, /**< SCIP data structure */
1752  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
1753  )
1754 {
1755  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgPseudocost", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1756 
1757  return SCIPhistoryGetPseudocost(scip->stat->glbhistory, solvaldelta);
1758 }
1759 
1760 /** gets the average pseudo cost value for the given direction over all variables,
1761  * only using the pseudo cost information of the current run
1762  *
1763  * @return the average pseudo cost value for the given direction over all variables,
1764  * only using the pseudo cost information of the current run
1765  *
1766  * @pre This method can be called if SCIP is in one of the following stages:
1767  * - \ref SCIP_STAGE_SOLVING
1768  * - \ref SCIP_STAGE_SOLVED
1769  */
1771  SCIP* scip, /**< SCIP data structure */
1772  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
1773  )
1774 {
1775  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgPseudocostCurrentRun", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1776 
1777  return SCIPhistoryGetPseudocost(scip->stat->glbhistorycrun, solvaldelta);
1778 }
1779 
1780 /** gets the average number of pseudo cost updates for the given direction over all variables
1781  *
1782  * @return the average number of pseudo cost updates for the given direction over all variables
1783  *
1784  * @pre This method can be called if SCIP is in one of the following stages:
1785  * - \ref SCIP_STAGE_SOLVING
1786  * - \ref SCIP_STAGE_SOLVED
1787  */
1789  SCIP* scip, /**< SCIP data structure */
1790  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1791  )
1792 {
1793  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgPseudocostCount", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1794 
1795  return SCIPhistoryGetPseudocostCount(scip->stat->glbhistory, dir)
1796  / MAX(scip->transprob->nbinvars + scip->transprob->nintvars, 1);
1797 }
1798 
1799 /** gets the average number of pseudo cost updates for the given direction over all variables,
1800  * only using the pseudo cost information of the current run
1801  *
1802  * @return the average number of pseudo cost updates for the given direction over all variables,
1803  * only using the pseudo cost information of the current run
1804  *
1805  * @pre This method can be called if SCIP is in one of the following stages:
1806  * - \ref SCIP_STAGE_SOLVING
1807  * - \ref SCIP_STAGE_SOLVED
1808  */
1810  SCIP* scip, /**< SCIP data structure */
1811  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1812  )
1813 {
1814  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgPseudocostCountCurrentRun", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1815 
1817  / MAX(scip->transprob->nbinvars + scip->transprob->nintvars, 1);
1818 }
1819 
1820 /** gets the average pseudo cost score value over all variables, assuming a fractionality of 0.5
1821  *
1822  * @return the average pseudo cost score value over all variables, assuming a fractionality of 0.5
1823  *
1824  * @pre This method can be called if SCIP is in one of the following stages:
1825  * - \ref SCIP_STAGE_SOLVING
1826  * - \ref SCIP_STAGE_SOLVED
1827  */
1829  SCIP* scip /**< SCIP data structure */
1830  )
1831 {
1832  SCIP_Real pscostdown;
1833  SCIP_Real pscostup;
1834 
1835  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgPseudocostScore", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1836 
1837  pscostdown = SCIPhistoryGetPseudocost(scip->stat->glbhistory, -0.5);
1838  pscostup = SCIPhistoryGetPseudocost(scip->stat->glbhistory, +0.5);
1839 
1840  return SCIPbranchGetScore(scip->set, NULL, pscostdown, pscostup);
1841 }
1842 
1843 /** returns the variance of pseudo costs for all variables in the requested direction
1844  *
1845  * @return the variance of pseudo costs for all variables in the requested direction
1846  *
1847  * @pre This method can be called if SCIP is in one of the following stages:
1848  * - \ref SCIP_STAGE_SOLVING
1849  * - \ref SCIP_STAGE_SOLVED
1850  */
1852  SCIP* scip, /**< SCIP data structure */
1853  SCIP_BRANCHDIR branchdir, /**< the branching direction, up or down */
1854  SCIP_Bool onlycurrentrun /**< use only history of current run? */
1855  )
1856 {
1857  SCIP_HISTORY* history;
1858 
1859  assert(scip != NULL);
1860  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetPseudocostVariance", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1861 
1862  history = (onlycurrentrun ? scip->stat->glbhistorycrun : scip->stat->glbhistory);
1863  assert(history != NULL);
1864 
1865  return SCIPhistoryGetPseudocostVariance(history, branchdir);
1866 }
1867 
1868 /** gets the number of pseudo cost updates for the given direction over all variables
1869  *
1870  * @return the number of pseudo cost updates for the given direction over all variables
1871  *
1872  * @pre This method can be called if SCIP is in one of the following stages:
1873  * - \ref SCIP_STAGE_SOLVING
1874  * - \ref SCIP_STAGE_SOLVED
1875  */
1877  SCIP* scip, /**< SCIP data structure */
1878  SCIP_BRANCHDIR dir, /**< branching direction (downwards, or upwards) */
1879  SCIP_Bool onlycurrentrun /**< use only history of current run? */
1880  )
1881 {
1882  SCIP_HISTORY* history;
1883 
1884  assert(scip != NULL);
1885  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetPseudocostCount", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1886 
1887  history = (onlycurrentrun ? scip->stat->glbhistorycrun : scip->stat->glbhistory);
1888 
1889  return SCIPhistoryGetPseudocostCount(history, dir);
1890 }
1891 
1892 /** gets the average pseudo cost score value over all variables, assuming a fractionality of 0.5,
1893  * only using the pseudo cost information of the current run
1894  *
1895  * @return the average pseudo cost score value over all variables, assuming a fractionality of 0.5,
1896  * only using the pseudo cost information of the current run
1897  *
1898  * @pre This method can be called if SCIP is in one of the following stages:
1899  * - \ref SCIP_STAGE_SOLVING
1900  * - \ref SCIP_STAGE_SOLVED
1901  */
1903  SCIP* scip /**< SCIP data structure */
1904  )
1905 {
1906  SCIP_Real pscostdown;
1907  SCIP_Real pscostup;
1908 
1909  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgPseudocostScoreCurrentRun", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1910 
1911  pscostdown = SCIPhistoryGetPseudocost(scip->stat->glbhistorycrun, -0.5);
1912  pscostup = SCIPhistoryGetPseudocost(scip->stat->glbhistorycrun, +0.5);
1913 
1914  return SCIPbranchGetScore(scip->set, NULL, pscostdown, pscostup);
1915 }
1916 
1917 /** gets the average conflict score value over all variables
1918  *
1919  * @return the average conflict score value over all variables
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  */
1926  SCIP* scip /**< SCIP data structure */
1927  )
1928 {
1929  SCIP_Real conflictscoredown;
1930  SCIP_Real conflictscoreup;
1931  SCIP_Real scale;
1932 
1933  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgConflictScore", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1934 
1935  scale = scip->transprob->nvars * scip->stat->vsidsweight;
1936  conflictscoredown = SCIPhistoryGetVSIDS(scip->stat->glbhistory, SCIP_BRANCHDIR_DOWNWARDS) / scale;
1937  conflictscoreup = SCIPhistoryGetVSIDS(scip->stat->glbhistory, SCIP_BRANCHDIR_UPWARDS) / scale;
1938 
1939  return SCIPbranchGetScore(scip->set, NULL, conflictscoredown, conflictscoreup);
1940 }
1941 
1942 /** gets the average conflict score value over all variables, only using the conflict score information of the current run
1943  *
1944  * @return the average conflict score value over all variables, only using the conflict score information of the current run
1945  *
1946  * @pre This method can be called if SCIP is in one of the following stages:
1947  * - \ref SCIP_STAGE_SOLVING
1948  * - \ref SCIP_STAGE_SOLVED
1949  */
1951  SCIP* scip /**< SCIP data structure */
1952  )
1953 {
1954  SCIP_Real conflictscoredown;
1955  SCIP_Real conflictscoreup;
1956  SCIP_Real scale;
1957 
1958  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgConflictScoreCurrentRun", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1959 
1960  scale = scip->transprob->nvars * scip->stat->vsidsweight;
1961  conflictscoredown = SCIPhistoryGetVSIDS(scip->stat->glbhistorycrun, SCIP_BRANCHDIR_DOWNWARDS) / scale;
1962  conflictscoreup = SCIPhistoryGetVSIDS(scip->stat->glbhistorycrun, SCIP_BRANCHDIR_UPWARDS) / scale;
1963 
1964  return SCIPbranchGetScore(scip->set, NULL, conflictscoredown, conflictscoreup);
1965 }
1966 
1967 /** gets the average inference score value over all variables
1968  *
1969  * @return the average inference score value over all variables
1970  *
1971  * @pre This method can be called if SCIP is in one of the following stages:
1972  * - \ref SCIP_STAGE_SOLVING
1973  * - \ref SCIP_STAGE_SOLVED
1974  */
1976  SCIP* scip /**< SCIP data structure */
1977  )
1978 {
1979  SCIP_Real conflictlengthdown;
1980  SCIP_Real conflictlengthup;
1981 
1982  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgConflictlengthScore", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1983 
1986 
1987  return SCIPbranchGetScore(scip->set, NULL, conflictlengthdown, conflictlengthup);
1988 }
1989 
1990 /** gets the average conflictlength score value over all variables, only using the conflictlength information of the
1991  * current run
1992  *
1993  * @return the average conflictlength score value over all variables, only using the conflictlength information of the
1994  * current run
1995  *
1996  * @pre This method can be called if SCIP is in one of the following stages:
1997  * - \ref SCIP_STAGE_SOLVING
1998  * - \ref SCIP_STAGE_SOLVED
1999  */
2001  SCIP* scip /**< SCIP data structure */
2002  )
2003 {
2004  SCIP_Real conflictlengthdown;
2005  SCIP_Real conflictlengthup;
2006 
2007  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgConflictlengthScoreCurrentRun", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2008 
2011 
2012  return SCIPbranchGetScore(scip->set, NULL, conflictlengthdown, conflictlengthup);
2013 }
2014 
2015 /** returns the average number of inferences found after branching in given direction over all variables
2016  *
2017  * @return the average number of inferences found after branching in given direction over all variables
2018  *
2019  * @pre This method can be called if SCIP is in one of the following stages:
2020  * - \ref SCIP_STAGE_SOLVING
2021  * - \ref SCIP_STAGE_SOLVED
2022  */
2024  SCIP* scip, /**< SCIP data structure */
2025  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
2026  )
2027 {
2028  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgInferences", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2029 
2030  return SCIPhistoryGetAvgInferences(scip->stat->glbhistory, dir);
2031 }
2032 
2033 /** returns the average number of inferences found after branching in given direction over all variables,
2034  * only using the inference information of the current run
2035  *
2036  * @return the average number of inferences found after branching in given direction over all variables,
2037  * only using the inference information of the current run
2038  *
2039  * @pre This method can be called if SCIP is in one of the following stages:
2040  * - \ref SCIP_STAGE_SOLVING
2041  * - \ref SCIP_STAGE_SOLVED
2042  */
2044  SCIP* scip, /**< SCIP data structure */
2045  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
2046  )
2047 {
2048  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgInferencesCurrentRun", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2049 
2050  return SCIPhistoryGetAvgInferences(scip->stat->glbhistorycrun, dir);
2051 }
2052 
2053 /** gets the average inference score value over all variables
2054  *
2055  * @return the average inference score value over all variables
2056  *
2057  * @pre This method can be called if SCIP is in one of the following stages:
2058  * - \ref SCIP_STAGE_SOLVING
2059  * - \ref SCIP_STAGE_SOLVED
2060  */
2062  SCIP* scip /**< SCIP data structure */
2063  )
2064 {
2065  SCIP_Real inferencesdown;
2066  SCIP_Real inferencesup;
2067 
2068  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgInferenceScore", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2069 
2072 
2073  return SCIPbranchGetScore(scip->set, NULL, inferencesdown, inferencesup);
2074 }
2075 
2076 /** gets the average inference score value over all variables, only using the inference information of the
2077  * current run
2078  *
2079  * @return the average inference score value over all variables, only using the inference information of the
2080  * current run
2081  *
2082  * @pre This method can be called if SCIP is in one of the following stages:
2083  * - \ref SCIP_STAGE_SOLVING
2084  * - \ref SCIP_STAGE_SOLVED
2085  */
2087  SCIP* scip /**< SCIP data structure */
2088  )
2089 {
2090  SCIP_Real inferencesdown;
2091  SCIP_Real inferencesup;
2092 
2093  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgInferenceScoreCurrentRun", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2094 
2097 
2098  return SCIPbranchGetScore(scip->set, NULL, inferencesdown, inferencesup);
2099 }
2100 
2101 /** returns the average number of cutoffs found after branching in given direction over all variables
2102  *
2103  * @return the average number of cutoffs found after branching in given direction over all variables
2104  *
2105  * @pre This method can be called if SCIP is in one of the following stages:
2106  * - \ref SCIP_STAGE_SOLVING
2107  * - \ref SCIP_STAGE_SOLVED
2108  */
2110  SCIP* scip, /**< SCIP data structure */
2111  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
2112  )
2113 {
2114  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgCutoffs", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2115 
2116  return SCIPhistoryGetAvgCutoffs(scip->stat->glbhistory, dir);
2117 }
2118 
2119 /** returns the average number of cutoffs found after branching in given direction over all variables,
2120  * only using the cutoff information of the current run
2121  *
2122  * @return the average number of cutoffs found after branching in given direction over all variables,
2123  * only using the cutoff information of the current run
2124  *
2125  * @pre This method can be called if SCIP is in one of the following stages:
2126  * - \ref SCIP_STAGE_SOLVING
2127  * - \ref SCIP_STAGE_SOLVED
2128  */
2130  SCIP* scip, /**< SCIP data structure */
2131  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
2132  )
2133 {
2134  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgCutoffsCurrentRun", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2135 
2136  return SCIPhistoryGetAvgCutoffs(scip->stat->glbhistorycrun, dir);
2137 }
2138 
2139 /** gets the average cutoff score value over all variables
2140  *
2141  * @return the average cutoff score value over all variables
2142  *
2143  * @pre This method can be called if SCIP is in one of the following stages:
2144  * - \ref SCIP_STAGE_SOLVING
2145  * - \ref SCIP_STAGE_SOLVED
2146  */
2148  SCIP* scip /**< SCIP data structure */
2149  )
2150 {
2151  SCIP_Real cutoffsdown;
2152  SCIP_Real cutoffsup;
2153 
2154  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgCutoffScore", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2155 
2158 
2159  return SCIPbranchGetScore(scip->set, NULL, cutoffsdown, cutoffsup);
2160 }
2161 
2162 /** gets the average cutoff score value over all variables, only using the cutoff score information of the current run
2163  *
2164  * @return the average cutoff score value over all variables, only using the cutoff score information of the current run
2165  *
2166  * @pre This method can be called if SCIP is in one of the following stages:
2167  * - \ref SCIP_STAGE_SOLVING
2168  * - \ref SCIP_STAGE_SOLVED
2169  */
2171  SCIP* scip /**< SCIP data structure */
2172  )
2173 {
2174  SCIP_Real cutoffsdown;
2175  SCIP_Real cutoffsup;
2176 
2177  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgCutoffScoreCurrentRun", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2178 
2181 
2182  return SCIPbranchGetScore(scip->set, NULL, cutoffsdown, cutoffsup);
2183 }
2184 
2185 /** computes a deterministic measure of time from statistics
2186  *
2187  * @return the deterministic time
2188  *
2189  * @pre This method can be called if SCIP is in one of the following stages:
2190  * - \ref SCIP_STAGE_PRESOLVING
2191  * - \ref SCIP_STAGE_PRESOLVED
2192  * - \ref SCIP_STAGE_SOLVING
2193  * - \ref SCIP_STAGE_SOLVED
2194  */
2196  SCIP* scip /**< SCIP data structure */
2197  )
2198 {
2199 /* TODO: SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetDeterministicTime", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) ); */
2200  if(scip->stat == NULL)
2201  return 0.0;
2202 
2203  return 1e-6 * scip->stat->nnz * (
2204  0.00328285264101 * scip->stat->nprimalresolvelpiterations +
2205  0.00531625104146 * scip->stat->ndualresolvelpiterations +
2206  0.000738719124051 * scip->stat->nprobboundchgs +
2207  0.0011123144764 * scip->stat->nisstoppedcalls );
2208 }
2209 
2210 /** outputs problem to file stream */
2211 static
2213  SCIP* scip, /**< SCIP data structure */
2214  SCIP_PROB* prob, /**< problem data */
2215  FILE* file, /**< output file (or NULL for standard output) */
2216  const char* extension, /**< file format (or NULL for default CIP format) */
2217  SCIP_Bool genericnames /**< using generic variable and constraint names? */
2218  )
2219 {
2220  SCIP_RESULT result;
2221  int i;
2222  assert(scip != NULL);
2223  assert(prob != NULL);
2224 
2225  /* try all readers until one could read the file */
2226  result = SCIP_DIDNOTRUN;
2227  for( i = 0; i < scip->set->nreaders && result == SCIP_DIDNOTRUN; ++i )
2228  {
2229  SCIP_RETCODE retcode;
2230 
2231  if( extension != NULL )
2232  retcode = SCIPreaderWrite(scip->set->readers[i], prob, scip->set, file, extension, genericnames, &result);
2233  else
2234  retcode = SCIPreaderWrite(scip->set->readers[i], prob, scip->set, file, "cip", genericnames, &result);
2235 
2236  /* check for reader errors */
2237  if( retcode == SCIP_WRITEERROR )
2238  return retcode;
2239 
2240  SCIP_CALL( retcode );
2241  }
2242 
2243  switch( result )
2244  {
2245  case SCIP_DIDNOTRUN:
2246  return SCIP_PLUGINNOTFOUND;
2247 
2248  case SCIP_SUCCESS:
2249  return SCIP_OKAY;
2250 
2251  default:
2252  assert(i < scip->set->nreaders);
2253  SCIPerrorMessage("invalid result code <%d> from reader <%s> writing <%s> format\n",
2254  result, SCIPreaderGetName(scip->set->readers[i]), extension);
2255  return SCIP_READERROR;
2256  } /*lint !e788*/
2257 }
2258 
2259 /** outputs original problem to file stream
2260  *
2261  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2262  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2263  *
2264  * @pre This method can be called if SCIP is in one of the following stages:
2265  * - \ref SCIP_STAGE_PROBLEM
2266  * - \ref SCIP_STAGE_TRANSFORMING
2267  * - \ref SCIP_STAGE_TRANSFORMED
2268  * - \ref SCIP_STAGE_INITPRESOLVE
2269  * - \ref SCIP_STAGE_PRESOLVING
2270  * - \ref SCIP_STAGE_EXITPRESOLVE
2271  * - \ref SCIP_STAGE_PRESOLVED
2272  * - \ref SCIP_STAGE_INITSOLVE
2273  * - \ref SCIP_STAGE_SOLVING
2274  * - \ref SCIP_STAGE_SOLVED
2275  * - \ref SCIP_STAGE_EXITSOLVE
2276  * - \ref SCIP_STAGE_FREETRANS
2277  */
2279  SCIP* scip, /**< SCIP data structure */
2280  FILE* file, /**< output file (or NULL for standard output) */
2281  const char* extension, /**< file format (or NULL for default CIP format)*/
2282  SCIP_Bool genericnames /**< using generic variable and constraint names? */
2283  )
2284 {
2285  SCIP_RETCODE retcode;
2286 
2287  SCIP_CALL( SCIPcheckStage(scip, "SCIPprintOrigProblem", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
2288 
2289  assert(scip != NULL);
2290  assert( scip->origprob != NULL );
2291 
2292  retcode = printProblem(scip, scip->origprob, file, extension, genericnames);
2293 
2294  /* check for write errors */
2295  if( retcode == SCIP_WRITEERROR || retcode == SCIP_PLUGINNOTFOUND )
2296  return retcode;
2297  else
2298  {
2299  SCIP_CALL( retcode );
2300  }
2301 
2302  return SCIP_OKAY;
2303 }
2304 
2305 /** outputs transformed problem of the current node to file stream
2306  *
2307  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2308  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2309  *
2310  * @pre This method can be called if SCIP is in one of the following stages:
2311  * - \ref SCIP_STAGE_TRANSFORMED
2312  * - \ref SCIP_STAGE_INITPRESOLVE
2313  * - \ref SCIP_STAGE_PRESOLVING
2314  * - \ref SCIP_STAGE_EXITPRESOLVE
2315  * - \ref SCIP_STAGE_PRESOLVED
2316  * - \ref SCIP_STAGE_INITSOLVE
2317  * - \ref SCIP_STAGE_SOLVING
2318  * - \ref SCIP_STAGE_SOLVED
2319  * - \ref SCIP_STAGE_EXITSOLVE
2320  * - \ref SCIP_STAGE_FREETRANS
2321  */
2323  SCIP* scip, /**< SCIP data structure */
2324  FILE* file, /**< output file (or NULL for standard output) */
2325  const char* extension, /**< file format (or NULL for default CIP format)*/
2326  SCIP_Bool genericnames /**< using generic variable and constraint names? */
2327  )
2328 {
2329  SCIP_RETCODE retcode;
2330 
2331  SCIP_CALL( SCIPcheckStage(scip, "SCIPprintTransProblem", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
2332 
2333  assert(scip != NULL);
2334  assert(scip->transprob != NULL );
2335 
2336  retcode = printProblem(scip, scip->transprob, file, extension, genericnames);
2337 
2338  /* check for write errors */
2339  if( retcode == SCIP_WRITEERROR || retcode == SCIP_PLUGINNOTFOUND )
2340  return retcode;
2341  else
2342  {
2343  SCIP_CALL( retcode );
2344  }
2345 
2346  return SCIP_OKAY;
2347 }
2348 
2349 /** outputs status statistics
2350  *
2351  * @note If limits have been changed between the solution and the call to this function, the status is recomputed and
2352  * thus may to correspond to the original status.
2353  *
2354  * @pre This method can be called if SCIP is in one of the following stages:
2355  * - \ref SCIP_STAGE_INIT
2356  * - \ref SCIP_STAGE_PROBLEM
2357  * - \ref SCIP_STAGE_TRANSFORMED
2358  * - \ref SCIP_STAGE_INITPRESOLVE
2359  * - \ref SCIP_STAGE_PRESOLVING
2360  * - \ref SCIP_STAGE_EXITPRESOLVE
2361  * - \ref SCIP_STAGE_PRESOLVED
2362  * - \ref SCIP_STAGE_SOLVING
2363  * - \ref SCIP_STAGE_SOLVED
2364  */
2366  SCIP* scip, /**< SCIP data structure */
2367  FILE* file /**< output file */
2368  )
2369 {
2370  assert(scip != NULL);
2371  assert(scip->set != NULL);
2372 
2373  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintStatusStatistics", TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2374 
2375  SCIPmessageFPrintInfo(scip->messagehdlr, file, "SCIP Status : ");
2376  SCIP_CALL_ABORT( SCIPprintStage(scip, file) );
2377  SCIPmessageFPrintInfo(scip->messagehdlr, file, "\n");
2378 }
2379 
2380 /** outputs statistics for original problem
2381  *
2382  * @pre This method can be called if SCIP is in one of the following stages:
2383  * - \ref SCIP_STAGE_PROBLEM
2384  * - \ref SCIP_STAGE_TRANSFORMED
2385  * - \ref SCIP_STAGE_INITPRESOLVE
2386  * - \ref SCIP_STAGE_PRESOLVING
2387  * - \ref SCIP_STAGE_EXITPRESOLVE
2388  * - \ref SCIP_STAGE_PRESOLVED
2389  * - \ref SCIP_STAGE_SOLVING
2390  * - \ref SCIP_STAGE_SOLVED
2391  */
2393  SCIP* scip, /**< SCIP data structure */
2394  FILE* file /**< output file */
2395  )
2396 {
2397  assert(scip != NULL);
2398  assert(scip->set != NULL);
2399 
2400  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintOrigProblemStatistics", FALSE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2401 
2402  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Original Problem :\n");
2403  SCIPprobPrintStatistics(scip->origprob, scip->set, scip->messagehdlr, file);
2404 }
2405 
2406 /** outputs statistics for transformed problem
2407  *
2408  * @pre This method can be called if SCIP is in one of the following stages:
2409  * - \ref SCIP_STAGE_PROBLEM
2410  * - \ref SCIP_STAGE_TRANSFORMED
2411  * - \ref SCIP_STAGE_INITPRESOLVE
2412  * - \ref SCIP_STAGE_PRESOLVING
2413  * - \ref SCIP_STAGE_EXITPRESOLVE
2414  * - \ref SCIP_STAGE_PRESOLVED
2415  * - \ref SCIP_STAGE_SOLVING
2416  * - \ref SCIP_STAGE_SOLVED
2417  */
2419  SCIP* scip, /**< SCIP data structure */
2420  FILE* file /**< output file */
2421  )
2422 {
2423  assert(scip != NULL);
2424  assert(scip->set != NULL);
2425 
2426  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintTransProblemStatistics", FALSE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2427 
2428  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Presolved Problem :\n");
2429  SCIPprobPrintStatistics(scip->transprob, scip->set, scip->messagehdlr, file);
2430 }
2431 
2432 /** outputs presolver statistics
2433  *
2434  * @pre This method can be called if SCIP is in one of the following stages:
2435  * - \ref SCIP_STAGE_TRANSFORMED
2436  * - \ref SCIP_STAGE_INITPRESOLVE
2437  * - \ref SCIP_STAGE_PRESOLVING
2438  * - \ref SCIP_STAGE_EXITPRESOLVE
2439  * - \ref SCIP_STAGE_PRESOLVED
2440  * - \ref SCIP_STAGE_SOLVING
2441  * - \ref SCIP_STAGE_SOLVED
2442  */
2444  SCIP* scip, /**< SCIP data structure */
2445  FILE* file /**< output file */
2446  )
2447 {
2448  int i;
2449 
2450  assert(scip != NULL);
2451  assert(scip->set != NULL);
2452 
2453  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintPresolverStatistics", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2454 
2455  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Presolvers : ExecTime SetupTime Calls FixedVars AggrVars ChgTypes ChgBounds AddHoles DelCons AddCons ChgSides ChgCoefs\n");
2456 
2457  /* sort presolvers w.r.t. their name */
2458  SCIPsetSortPresolsName(scip->set);
2459 
2460  /* presolver statistics */
2461  for( i = 0; i < scip->set->npresols; ++i )
2462  {
2463  SCIP_PRESOL* presol;
2464  presol = scip->set->presols[i];
2465  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s:", SCIPpresolGetName(presol));
2466  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f %10.2f %6d %10d %10d %10d %10d %10d %10d %10d %10d %10d\n",
2467  SCIPpresolGetTime(presol),
2468  SCIPpresolGetSetupTime(presol),
2469  SCIPpresolGetNCalls(presol),
2470  SCIPpresolGetNFixedVars(presol),
2471  SCIPpresolGetNAggrVars(presol),
2472  SCIPpresolGetNChgVarTypes(presol),
2473  SCIPpresolGetNChgBds(presol),
2474  SCIPpresolGetNAddHoles(presol),
2475  SCIPpresolGetNDelConss(presol),
2476  SCIPpresolGetNAddConss(presol),
2477  SCIPpresolGetNChgSides(presol),
2478  SCIPpresolGetNChgCoefs(presol));
2479  }
2480 
2481  /* sort propagators w.r.t. their name */
2482  SCIPsetSortPropsName(scip->set);
2483 
2484  for( i = 0; i < scip->set->nprops; ++i )
2485  {
2486  SCIP_PROP* prop;
2487  prop = scip->set->props[i];
2488  if( SCIPpropDoesPresolve(prop) )
2489  {
2490  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s:", SCIPpropGetName(prop));
2491  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f %10.2f %6d %10d %10d %10d %10d %10d %10d %10d %10d %10d\n",
2492  SCIPpropGetPresolTime(prop),
2493  SCIPpropGetSetupTime(prop),
2495  SCIPpropGetNFixedVars(prop),
2496  SCIPpropGetNAggrVars(prop),
2498  SCIPpropGetNChgBds(prop),
2499  SCIPpropGetNAddHoles(prop),
2500  SCIPpropGetNDelConss(prop),
2501  SCIPpropGetNAddConss(prop),
2502  SCIPpropGetNChgSides(prop),
2503  SCIPpropGetNChgCoefs(prop));
2504  }
2505  }
2506 
2507  /* constraint handler presolving methods statistics */
2508  for( i = 0; i < scip->set->nconshdlrs; ++i )
2509  {
2510  SCIP_CONSHDLR* conshdlr;
2511  int maxnactiveconss;
2512 
2513  conshdlr = scip->set->conshdlrs[i];
2514  maxnactiveconss = SCIPconshdlrGetMaxNActiveConss(conshdlr);
2515  if( SCIPconshdlrDoesPresolve(conshdlr)
2516  && (maxnactiveconss > 0 || !SCIPconshdlrNeedsCons(conshdlr)
2517  || SCIPconshdlrGetNFixedVars(conshdlr) > 0
2518  || SCIPconshdlrGetNAggrVars(conshdlr) > 0
2519  || SCIPconshdlrGetNChgVarTypes(conshdlr) > 0
2520  || SCIPconshdlrGetNChgBds(conshdlr) > 0
2521  || SCIPconshdlrGetNAddHoles(conshdlr) > 0
2522  || SCIPconshdlrGetNDelConss(conshdlr) > 0
2523  || SCIPconshdlrGetNAddConss(conshdlr) > 0
2524  || SCIPconshdlrGetNChgSides(conshdlr) > 0
2525  || SCIPconshdlrGetNChgCoefs(conshdlr) > 0
2526  || SCIPconshdlrGetNUpgdConss(conshdlr) > 0) )
2527  {
2528  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s:", SCIPconshdlrGetName(conshdlr));
2529  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f %10.2f %6d %10d %10d %10d %10d %10d %10d %10d %10d %10d\n",
2530  SCIPconshdlrGetPresolTime(conshdlr),
2531  SCIPconshdlrGetSetupTime(conshdlr),
2532  SCIPconshdlrGetNPresolCalls(conshdlr),
2533  SCIPconshdlrGetNFixedVars(conshdlr),
2534  SCIPconshdlrGetNAggrVars(conshdlr),
2535  SCIPconshdlrGetNChgVarTypes(conshdlr),
2536  SCIPconshdlrGetNChgBds(conshdlr),
2537  SCIPconshdlrGetNAddHoles(conshdlr),
2538  SCIPconshdlrGetNDelConss(conshdlr),
2539  SCIPconshdlrGetNAddConss(conshdlr),
2540  SCIPconshdlrGetNChgSides(conshdlr),
2541  SCIPconshdlrGetNChgCoefs(conshdlr));
2542  }
2543  }
2544 
2545  /* root node bound changes */
2546  SCIPmessageFPrintInfo(scip->messagehdlr, file, " root node : - - - %10d - - %10d - - - - -\n",
2547  scip->stat->nrootintfixings, scip->stat->nrootboundchgs);
2548 }
2549 
2550 /** outputs constraint statistics
2551  *
2552  * @pre This method can be called if SCIP is in one of the following stages:
2553  * - \ref SCIP_STAGE_TRANSFORMED
2554  * - \ref SCIP_STAGE_INITPRESOLVE
2555  * - \ref SCIP_STAGE_PRESOLVING
2556  * - \ref SCIP_STAGE_EXITPRESOLVE
2557  * - \ref SCIP_STAGE_PRESOLVED
2558  * - \ref SCIP_STAGE_SOLVING
2559  * - \ref SCIP_STAGE_SOLVED
2560  */
2562  SCIP* scip, /**< SCIP data structure */
2563  FILE* file /**< output file */
2564  )
2565 {
2566  int i;
2567 
2568  assert(scip != NULL);
2569  assert(scip->set != NULL);
2570 
2571  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintConstraintStatistics", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2572 
2573  /* Add maximal number of constraints of the same type? So far this information is not added because of lack of space. */
2574  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Constraints : Number MaxNumber #Separate #Propagate #EnfoLP #EnfoRelax #EnfoPS #Check #ResProp Cutoffs DomReds Cuts Applied Conss Children\n");
2575 
2576  for( i = 0; i < scip->set->nconshdlrs; ++i )
2577  {
2578  SCIP_CONSHDLR* conshdlr;
2579  int startnactiveconss;
2580  int maxnactiveconss;
2581 
2582  conshdlr = scip->set->conshdlrs[i];
2583  startnactiveconss = SCIPconshdlrGetStartNActiveConss(conshdlr);
2584  maxnactiveconss = SCIPconshdlrGetMaxNActiveConss(conshdlr);
2585  if( maxnactiveconss > 0 || !SCIPconshdlrNeedsCons(conshdlr) )
2586  {
2587  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s:", SCIPconshdlrGetName(conshdlr));
2589  startnactiveconss,
2590  maxnactiveconss > startnactiveconss ? '+' : ' ',
2591  maxnactiveconss,
2592  SCIPconshdlrGetNSepaCalls(conshdlr),
2593  SCIPconshdlrGetNPropCalls(conshdlr),
2594  SCIPconshdlrGetNEnfoLPCalls(conshdlr),
2596  SCIPconshdlrGetNEnfoPSCalls(conshdlr),
2597  SCIPconshdlrGetNCheckCalls(conshdlr),
2598  SCIPconshdlrGetNRespropCalls(conshdlr),
2599  SCIPconshdlrGetNCutoffs(conshdlr),
2600  SCIPconshdlrGetNDomredsFound(conshdlr),
2601  SCIPconshdlrGetNCutsFound(conshdlr),
2602  SCIPconshdlrGetNCutsApplied(conshdlr),
2603  SCIPconshdlrGetNConssFound(conshdlr),
2604  SCIPconshdlrGetNChildren(conshdlr));
2605  }
2606  }
2607 }
2608 
2609 /** outputs constraint timing statistics
2610  *
2611  * @pre This method can be called if SCIP is in one of the following stages:
2612  * - \ref SCIP_STAGE_TRANSFORMED
2613  * - \ref SCIP_STAGE_INITPRESOLVE
2614  * - \ref SCIP_STAGE_PRESOLVING
2615  * - \ref SCIP_STAGE_EXITPRESOLVE
2616  * - \ref SCIP_STAGE_PRESOLVED
2617  * - \ref SCIP_STAGE_SOLVING
2618  * - \ref SCIP_STAGE_SOLVED
2619  */
2621  SCIP* scip, /**< SCIP data structure */
2622  FILE* file /**< output file */
2623  )
2624 {
2625  int i;
2626 
2627  assert(scip != NULL);
2628  assert(scip->set != NULL);
2629 
2630  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintConstraintTimingStatistics", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2631 
2632  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Constraint Timings : TotalTime SetupTime Separate Propagate EnfoLP EnfoPS EnfoRelax Check ResProp SB-Prop\n");
2633 
2634  for( i = 0; i < scip->set->nconshdlrs; ++i )
2635  {
2636  SCIP_CONSHDLR* conshdlr;
2637  int maxnactiveconss;
2638 
2639  conshdlr = scip->set->conshdlrs[i];
2640  maxnactiveconss = SCIPconshdlrGetMaxNActiveConss(conshdlr);
2641  if( maxnactiveconss > 0 || !SCIPconshdlrNeedsCons(conshdlr) )
2642  {
2643  SCIP_Real totaltime;
2644 
2645  totaltime = SCIPconshdlrGetSepaTime(conshdlr) + SCIPconshdlrGetPropTime(conshdlr)
2647  + SCIPconshdlrGetEnfoLPTime(conshdlr)
2648  + SCIPconshdlrGetEnfoPSTime(conshdlr)
2649  + SCIPconshdlrGetEnfoRelaxTime(conshdlr)
2650  + SCIPconshdlrGetCheckTime(conshdlr)
2651  + SCIPconshdlrGetRespropTime(conshdlr)
2652  + SCIPconshdlrGetSetupTime(conshdlr);
2653 
2654  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s:", SCIPconshdlrGetName(conshdlr));
2655  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f %10.2f %10.2f %10.2f %10.2f %10.2f %10.2f %10.2f %10.2f %10.2f\n",
2656  totaltime,
2657  SCIPconshdlrGetSetupTime(conshdlr),
2658  SCIPconshdlrGetSepaTime(conshdlr),
2659  SCIPconshdlrGetPropTime(conshdlr),
2660  SCIPconshdlrGetEnfoLPTime(conshdlr),
2661  SCIPconshdlrGetEnfoPSTime(conshdlr),
2662  SCIPconshdlrGetEnfoRelaxTime(conshdlr),
2663  SCIPconshdlrGetCheckTime(conshdlr),
2664  SCIPconshdlrGetRespropTime(conshdlr),
2666  }
2667  }
2668 }
2669 
2670 /** outputs propagator statistics
2671  *
2672  * @pre This method can be called if SCIP is in one of the following stages:
2673  * - \ref SCIP_STAGE_TRANSFORMED
2674  * - \ref SCIP_STAGE_INITPRESOLVE
2675  * - \ref SCIP_STAGE_PRESOLVING
2676  * - \ref SCIP_STAGE_EXITPRESOLVE
2677  * - \ref SCIP_STAGE_PRESOLVED
2678  * - \ref SCIP_STAGE_SOLVING
2679  * - \ref SCIP_STAGE_SOLVED
2680  */
2682  SCIP* scip, /**< SCIP data structure */
2683  FILE* file /**< output file */
2684  )
2685 {
2686  int i;
2687 
2688  assert(scip != NULL);
2689  assert(scip->set != NULL);
2690 
2691  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintPropagatorStatistics", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2692 
2693  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Propagators : #Propagate #ResProp Cutoffs DomReds\n");
2694 
2695  /* sort propagaters w.r.t. their name */
2696  SCIPsetSortPropsName(scip->set);
2697 
2698  for( i = 0; i < scip->set->nprops; ++i )
2699  {
2700  SCIP_PROP* prop;
2701  prop = scip->set->props[i];
2702 
2704  SCIPpropGetName(prop),
2705  SCIPpropGetNCalls(prop),
2707  SCIPpropGetNCutoffs(prop),
2708  SCIPpropGetNDomredsFound(prop));
2709  }
2710 
2711  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Propagator Timings : TotalTime SetupTime Presolve Propagate ResProp SB-Prop\n");
2712 
2713  for( i = 0; i < scip->set->nprops; ++i )
2714  {
2715  SCIP_PROP* prop;
2716  SCIP_Real totaltime;
2717 
2718  prop = scip->set->props[i];
2719  totaltime = SCIPpropGetPresolTime(prop) + SCIPpropGetTime(prop) + SCIPpropGetRespropTime(prop)
2721 
2722  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s:", SCIPpropGetName(prop));
2723  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f %10.2f %10.2f %10.2f %10.2f %10.2f\n",
2724  totaltime,
2725  SCIPpropGetSetupTime(prop),
2726  SCIPpropGetPresolTime(prop),
2727  SCIPpropGetTime(prop),
2728  SCIPpropGetRespropTime(prop),
2730  }
2731 }
2732 
2733 /** outputs conflict statistics
2734  *
2735  * @pre This method can be called if SCIP is in one of the following stages:
2736  * - \ref SCIP_STAGE_TRANSFORMED
2737  * - \ref SCIP_STAGE_INITPRESOLVE
2738  * - \ref SCIP_STAGE_PRESOLVING
2739  * - \ref SCIP_STAGE_EXITPRESOLVE
2740  * - \ref SCIP_STAGE_PRESOLVED
2741  * - \ref SCIP_STAGE_SOLVING
2742  * - \ref SCIP_STAGE_SOLVED
2743  */
2745  SCIP* scip, /**< SCIP data structure */
2746  FILE* file /**< output file */
2747  )
2748 {
2749  char initstoresize[SCIP_MAXSTRLEN];
2750  char maxstoresize[SCIP_MAXSTRLEN];
2751 
2752  assert(scip != NULL);
2753  assert(scip->set != NULL);
2754 
2755  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintConflictStatistics", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2756 
2757  if( scip->set->conf_maxstoresize == 0 )
2758  {
2759  (void)SCIPsnprintf(initstoresize, SCIP_MAXSTRLEN, "inf");
2760  (void)SCIPsnprintf(maxstoresize, SCIP_MAXSTRLEN, "inf");
2761  }
2762  else
2763  {
2764  int initsize = SCIPconflictstoreGetInitPoolSize(scip->conflictstore);
2765  int maxsize = SCIPconflictstoreGetMaxPoolSize(scip->conflictstore);
2766 
2767  if( maxsize == -1 )
2768  {
2769  (void)SCIPsnprintf(initstoresize, SCIP_MAXSTRLEN, "--");
2770  (void)SCIPsnprintf(maxstoresize, SCIP_MAXSTRLEN, "--");
2771  }
2772  else
2773  {
2774  assert(initsize >= 0);
2775  assert(maxsize >= 0);
2776 
2777  (void)SCIPsnprintf(initstoresize, SCIP_MAXSTRLEN, "%d", initsize);
2778  (void)SCIPsnprintf(maxstoresize, SCIP_MAXSTRLEN, "%d", maxsize);
2779  }
2780  }
2781  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Conflict Analysis : Time Calls Success DomReds Conflicts Literals Reconvs ReconvLits Dualrays Nonzeros LP Iters (pool size: [%s,%s])\n", initstoresize, maxstoresize);
2782  SCIPmessageFPrintInfo(scip->messagehdlr, file, " propagation : %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " - %10" SCIP_LONGINT_FORMAT " %10.1f %10" SCIP_LONGINT_FORMAT " %10.1f - - -\n",
2794  SCIPmessageFPrintInfo(scip->messagehdlr, file, " infeasible LP : %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " - %10" SCIP_LONGINT_FORMAT " %10.1f %10" SCIP_LONGINT_FORMAT " %10.1f %10" SCIP_LONGINT_FORMAT " %10.1f %10" SCIP_LONGINT_FORMAT "\n",
2811  SCIPmessageFPrintInfo(scip->messagehdlr, file, " bound exceed. LP : %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " - %10" SCIP_LONGINT_FORMAT " %10.1f %10" SCIP_LONGINT_FORMAT " %10.1f %10" SCIP_LONGINT_FORMAT " %10.1f %10" SCIP_LONGINT_FORMAT "\n",
2828  SCIPmessageFPrintInfo(scip->messagehdlr, file, " strong branching : %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " - %10" SCIP_LONGINT_FORMAT " %10.1f %10" SCIP_LONGINT_FORMAT " %10.1f - - %10" SCIP_LONGINT_FORMAT "\n",
2841  SCIPmessageFPrintInfo(scip->messagehdlr, file, " pseudo solution : %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " - %10" SCIP_LONGINT_FORMAT " %10.1f %10" SCIP_LONGINT_FORMAT " %10.1f - - -\n",
2853  SCIPmessageFPrintInfo(scip->messagehdlr, file, " applied globally : %10.2f - - %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.1f - - %10" SCIP_LONGINT_FORMAT " - -\n",
2861  SCIPmessageFPrintInfo(scip->messagehdlr, file, " applied locally : - - - %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.1f - - %10" SCIP_LONGINT_FORMAT " - -\n",
2869 }
2870 
2871 /** outputs separator statistics
2872  *
2873  * @pre This method can be called if SCIP is in one of the following stages:
2874  * - \ref SCIP_STAGE_SOLVING
2875  * - \ref SCIP_STAGE_SOLVED
2876  */
2878  SCIP* scip, /**< SCIP data structure */
2879  FILE* file /**< output file */
2880  )
2881 {
2882  int i;
2883 
2884  assert(scip != NULL);
2885  assert(scip->set != NULL);
2886 
2887  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintSeparatorStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2888 
2889  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Separators : ExecTime SetupTime Calls Cutoffs DomReds Cuts Applied Conss\n");
2890  SCIPmessageFPrintInfo(scip->messagehdlr, file, " cut pool : %10.2f %10" SCIP_LONGINT_FORMAT " - - %10" SCIP_LONGINT_FORMAT " - - (maximal pool size: %d)\n",
2891  SCIPcutpoolGetTime(scip->cutpool),
2895 
2896  /* sort separators w.r.t. their name */
2897  SCIPsetSortSepasName(scip->set);
2898 
2899  for( i = 0; i < scip->set->nsepas; ++i )
2900  {
2901  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s: %10.2f %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT "\n",
2902  SCIPsepaGetName(scip->set->sepas[i]),
2903  SCIPsepaGetTime(scip->set->sepas[i]),
2904  SCIPsepaGetSetupTime(scip->set->sepas[i]),
2905  SCIPsepaGetNCalls(scip->set->sepas[i]),
2906  SCIPsepaGetNCutoffs(scip->set->sepas[i]),
2907  SCIPsepaGetNDomredsFound(scip->set->sepas[i]),
2908  SCIPsepaGetNCutsFound(scip->set->sepas[i]),
2909  SCIPsepaGetNCutsApplied(scip->set->sepas[i]),
2910  SCIPsepaGetNConssFound(scip->set->sepas[i]));
2911  }
2912 }
2913 
2914 /** outputs pricer statistics
2915  *
2916  * @pre This method can be called if SCIP is in one of the following stages:
2917  * - \ref SCIP_STAGE_SOLVING
2918  * - \ref SCIP_STAGE_SOLVED
2919  */
2921  SCIP* scip, /**< SCIP data structure */
2922  FILE* file /**< output file */
2923  )
2924 {
2925  int i;
2926 
2927  assert(scip != NULL);
2928  assert(scip->set != NULL);
2929 
2930  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintPricerStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2931 
2932  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Pricers : ExecTime SetupTime Calls Vars\n");
2933  SCIPmessageFPrintInfo(scip->messagehdlr, file, " problem variables: %10.2f - %10d %10d\n",
2937 
2938  /* sort pricers w.r.t. their name */
2939  SCIPsetSortPricersName(scip->set);
2940 
2941  for( i = 0; i < scip->set->nactivepricers; ++i )
2942  {
2943  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s: %10.2f %10.2f %10d %10d\n",
2944  SCIPpricerGetName(scip->set->pricers[i]),
2945  SCIPpricerGetTime(scip->set->pricers[i]),
2946  SCIPpricerGetSetupTime(scip->set->pricers[i]),
2947  SCIPpricerGetNCalls(scip->set->pricers[i]),
2948  SCIPpricerGetNVarsFound(scip->set->pricers[i]));
2949  }
2950 }
2951 
2952 /** outputs branching rule statistics
2953  *
2954  * @pre This method can be called if SCIP is in one of the following stages:
2955  * - \ref SCIP_STAGE_SOLVING
2956  * - \ref SCIP_STAGE_SOLVED
2957  */
2959  SCIP* scip, /**< SCIP data structure */
2960  FILE* file /**< output file */
2961  )
2962 {
2963  int i;
2964 
2965  assert(scip != NULL);
2966  assert(scip->set != NULL);
2967 
2968  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintBranchruleStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2969 
2970  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Branching Rules : ExecTime SetupTime BranchLP BranchExt BranchPS Cutoffs DomReds Cuts Conss Children\n");
2971 
2972  /* sort branching rules w.r.t. their name */
2974 
2975  for( i = 0; i < scip->set->nbranchrules; ++i )
2976  {
2989  }
2990 }
2991 
2992 /** outputs heuristics statistics
2993  *
2994  * @pre This method can be called if SCIP is in one of the following stages:
2995  * - \ref SCIP_STAGE_PRESOLVING
2996  * - \ref SCIP_STAGE_EXITPRESOLVE
2997  * - \ref SCIP_STAGE_PRESOLVED
2998  * - \ref SCIP_STAGE_SOLVING
2999  * - \ref SCIP_STAGE_SOLVED
3000  */
3002  SCIP* scip, /**< SCIP data structure */
3003  FILE* file /**< output file */
3004  )
3005 {
3006  int ndivesets = 0;
3007  int i;
3008 
3009  assert(scip != NULL);
3010  assert(scip->set != NULL);
3011  assert(scip->tree != NULL);
3012 
3013  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintHeuristicStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3014 
3015  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Primal Heuristics : ExecTime SetupTime Calls Found Best\n");
3016  SCIPmessageFPrintInfo(scip->messagehdlr, file, " LP solutions : %10.2f - - %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT "\n",
3018  scip->stat->nlpsolsfound, scip->stat->nlpbestsolsfound);
3019  SCIPmessageFPrintInfo(scip->messagehdlr, file, " relax solutions : %10.2f - - %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT "\n",
3021  scip->stat->nrelaxsolsfound, scip->stat->nrelaxbestsolsfound);
3022  SCIPmessageFPrintInfo(scip->messagehdlr, file, " pseudo solutions : %10.2f - - %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT "\n",
3024  scip->stat->npssolsfound, scip->stat->npsbestsolsfound);
3025  SCIPmessageFPrintInfo(scip->messagehdlr, file, " strong branching : %10.2f - - %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT "\n",
3027  scip->stat->nsbsolsfound, scip->stat->nsbbestsolsfound);
3028 
3029  /* sort heuristics w.r.t. their names */
3030  SCIPsetSortHeursName(scip->set);
3031 
3032  for( i = 0; i < scip->set->nheurs; ++i )
3033  {
3034  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s: %10.2f %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT "\n",
3035  SCIPheurGetName(scip->set->heurs[i]),
3036  SCIPheurGetTime(scip->set->heurs[i]),
3037  SCIPheurGetSetupTime(scip->set->heurs[i]),
3038  SCIPheurGetNCalls(scip->set->heurs[i]),
3039  SCIPheurGetNSolsFound(scip->set->heurs[i]),
3040  SCIPheurGetNBestSolsFound(scip->set->heurs[i]));
3041 
3042  /* count heuristics that use diving; needed to determine output later */
3043  ndivesets += SCIPheurGetNDivesets(scip->set->heurs[i]);
3044  }
3045 
3046  SCIPmessageFPrintInfo(scip->messagehdlr, file, " other solutions : - - - %10" SCIP_LONGINT_FORMAT " -\n",
3047  scip->stat->nexternalsolsfound);
3048 
3049  if ( ndivesets > 0 )
3050  {
3051  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Diving Statistics : Calls Nodes LP Iters Backtracks Conflicts MinDepth MaxDepth AvgDepth RoundSols NLeafSols MinSolDpt MaxSolDpt AvgSolDpt\n");
3052  for( i = 0; i < scip->set->nheurs; ++i )
3053  {
3054  int s;
3055  for( s = 0; s < SCIPheurGetNDivesets(scip->set->heurs[i]); ++s )
3056  {
3057  SCIP_DIVESET* diveset = SCIPheurGetDivesets(scip->set->heurs[i])[s];
3058  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s: %10d", SCIPdivesetGetName(diveset), SCIPdivesetGetNCalls(diveset));
3059  if( SCIPdivesetGetNCalls(diveset) > 0 )
3060  {
3061  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10d %10d %10.1f %10" SCIP_LONGINT_FORMAT,
3062  SCIPdivesetGetNProbingNodes(diveset),
3063  SCIPdivesetGetNLPIterations(diveset),
3064  SCIPdivesetGetNBacktracks(diveset),
3065  SCIPdivesetGetNConflicts(diveset),
3066  SCIPdivesetGetMinDepth(diveset),
3067  SCIPdivesetGetMaxDepth(diveset),
3068  SCIPdivesetGetAvgDepth(diveset),
3070 
3071  if( SCIPdivesetGetNSolutionCalls(diveset) > 0 )
3072  {
3073  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10d %10d %10d %10.1f\n",
3078  }
3079  else
3080  SCIPmessageFPrintInfo(scip->messagehdlr, file, " - - - -\n");
3081  }
3082  else
3083  SCIPmessageFPrintInfo(scip->messagehdlr, file, " - - - - - - - - - - - -\n");
3084  }
3085  }
3086  }
3087 }
3088 
3089 /** outputs compression statistics
3090  *
3091  * @pre This method can be called if SCIP is in one of the following stages:
3092  * - \ref SCIP_STAGE_PRESOLVING
3093  * - \ref SCIP_STAGE_EXITPRESOLVE
3094  * - \ref SCIP_STAGE_PRESOLVED
3095  * - \ref SCIP_STAGE_SOLVING
3096  * - \ref SCIP_STAGE_SOLVED
3097  */
3099  SCIP* scip, /**< SCIP data structure */
3100  FILE* file /**< output file */
3101  )
3102 {
3103  int i;
3104 
3105  assert(scip != NULL);
3106 
3107  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintCompressionStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3108 
3109  /* only print compression statistics if tree reoptimization is enabled */
3110  if( !scip->set->reopt_enable )
3111  return;
3112 
3113  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Tree Compressions : ExecTime SetupTime Calls Found\n");
3114 
3115  /* sort compressions w.r.t. their names */
3116  SCIPsetSortComprsName(scip->set);
3117 
3118  for( i = 0; i < scip->set->ncomprs; ++i )
3119  {
3120  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s: %10.2f %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT "\n",
3121  SCIPcomprGetName(scip->set->comprs[i]),
3122  SCIPcomprGetTime(scip->set->comprs[i]),
3123  SCIPcomprGetSetupTime(scip->set->comprs[i]),
3124  SCIPcomprGetNCalls(scip->set->comprs[i]),
3125  SCIPcomprGetNFound(scip->set->comprs[i]));
3126  }
3127 }
3128 
3129 /** outputs LP statistics
3130  *
3131  * @pre This method can be called if SCIP is in one of the following stages:
3132  * - \ref SCIP_STAGE_SOLVING
3133  * - \ref SCIP_STAGE_SOLVED
3134  */
3136  SCIP* scip, /**< SCIP data structure */
3137  FILE* file /**< output file */
3138  )
3139 {
3140  assert(scip != NULL);
3141  assert(scip->stat != NULL);
3142  assert(scip->lp != NULL);
3143 
3144  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintLPStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3145 
3146  SCIPmessageFPrintInfo(scip->messagehdlr, file, "LP : Time Calls Iterations Iter/call Iter/sec Time-0-It Calls-0-It ItLimit\n");
3147 
3148  SCIPmessageFPrintInfo(scip->messagehdlr, file, " primal LP : %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.2f",
3150  scip->stat->nprimallps + scip->stat->nprimalzeroitlps,
3151  scip->stat->nprimallpiterations,
3152  scip->stat->nprimallps > 0 ? (SCIP_Real)scip->stat->nprimallpiterations/(SCIP_Real)scip->stat->nprimallps : 0.0);
3153  if( SCIPclockGetTime(scip->stat->primallptime) >= 0.01 )
3155  else
3156  SCIPmessageFPrintInfo(scip->messagehdlr, file, " -");
3157  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f %10" SCIP_LONGINT_FORMAT "\n",
3158  scip->stat->primalzeroittime,
3159  scip->stat->nprimalzeroitlps);
3160 
3161  SCIPmessageFPrintInfo(scip->messagehdlr, file, " dual LP : %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.2f",
3163  scip->stat->nduallps + scip->stat->ndualzeroitlps,
3164  scip->stat->nduallpiterations,
3165  scip->stat->nduallps > 0 ? (SCIP_Real)scip->stat->nduallpiterations/(SCIP_Real)scip->stat->nduallps : 0.0);
3166  if( SCIPclockGetTime(scip->stat->duallptime) >= 0.01 )
3168  else
3169  SCIPmessageFPrintInfo(scip->messagehdlr, file, " -");
3170  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f %10" SCIP_LONGINT_FORMAT "\n",
3171  scip->stat->dualzeroittime,
3172  scip->stat->ndualzeroitlps);
3173 
3174  SCIPmessageFPrintInfo(scip->messagehdlr, file, " lex dual LP : %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.2f",
3176  scip->stat->nlexduallps,
3177  scip->stat->nlexduallpiterations,
3178  scip->stat->nlexduallps > 0 ? (SCIP_Real)scip->stat->nlexduallpiterations/(SCIP_Real)scip->stat->nlexduallps : 0.0);
3179  if( SCIPclockGetTime(scip->stat->lexduallptime) >= 0.01 )
3181  else
3182  SCIPmessageFPrintInfo(scip->messagehdlr, file, " -\n");
3183 
3184  SCIPmessageFPrintInfo(scip->messagehdlr, file, " barrier LP : %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.2f",
3186  scip->stat->nbarrierlps,
3187  scip->stat->nbarrierlpiterations,
3188  scip->stat->nbarrierlps > 0 ? (SCIP_Real)scip->stat->nbarrierlpiterations/(SCIP_Real)scip->stat->nbarrierlps : 0.0);
3189  if( SCIPclockGetTime(scip->stat->barrierlptime) >= 0.01 )
3191  else
3192  SCIPmessageFPrintInfo(scip->messagehdlr, file, " -");
3193  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f %10" SCIP_LONGINT_FORMAT "\n",
3194  scip->stat->barrierzeroittime,
3195  scip->stat->nbarrierzeroitlps);
3196 
3197  SCIPmessageFPrintInfo(scip->messagehdlr, file, " resolve instable : %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.2f",
3199  scip->stat->nresolveinstablelps,
3202  if( SCIPclockGetTime(scip->stat->resolveinstablelptime) >= 0.01 )
3204  else
3205  SCIPmessageFPrintInfo(scip->messagehdlr, file, " -\n");
3206 
3207  SCIPmessageFPrintInfo(scip->messagehdlr, file, " diving/probing LP: %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.2f",
3209  scip->stat->ndivinglps,
3210  scip->stat->ndivinglpiterations,
3211  scip->stat->ndivinglps > 0 ? (SCIP_Real)scip->stat->ndivinglpiterations/(SCIP_Real)scip->stat->ndivinglps : 0.0);
3212  if( SCIPclockGetTime(scip->stat->divinglptime) >= 0.01 )
3214  else
3215  SCIPmessageFPrintInfo(scip->messagehdlr, file, " -\n");
3216 
3217  SCIPmessageFPrintInfo(scip->messagehdlr, file, " strong branching : %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.2f",
3219  scip->stat->nstrongbranchs,
3220  scip->stat->nsblpiterations,
3221  scip->stat->nstrongbranchs > 0 ? (SCIP_Real)scip->stat->nsblpiterations/(SCIP_Real)scip->stat->nstrongbranchs : 0.0);
3222  if( SCIPclockGetTime(scip->stat->strongbranchtime) >= 0.01 )
3224  else
3225  SCIPmessageFPrintInfo(scip->messagehdlr, file, " -");
3226  SCIPmessageFPrintInfo(scip->messagehdlr, file, " - - %10d\n", scip->stat->nsbtimesiterlimhit);
3227 
3228  SCIPmessageFPrintInfo(scip->messagehdlr, file, " (at root node) : - %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.2f -\n",
3229  scip->stat->nrootstrongbranchs,
3230  scip->stat->nrootsblpiterations,
3231  scip->stat->nrootstrongbranchs > 0
3233 
3234  SCIPmessageFPrintInfo(scip->messagehdlr, file, " conflict analysis: %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.2f",
3236  scip->stat->nconflictlps,
3237  scip->stat->nconflictlpiterations,
3238  scip->stat->nconflictlps > 0 ? (SCIP_Real)scip->stat->nconflictlpiterations/(SCIP_Real)scip->stat->nconflictlps : 0.0);
3239  if( SCIPclockGetTime(scip->stat->conflictlptime) >= 0.01 )
3241  else
3242  SCIPmessageFPrintInfo(scip->messagehdlr, file, " -\n");
3243 }
3244 
3245 /** outputs NLP statistics
3246  *
3247  * @pre This method can be called if SCIP is in one of the following stages:
3248  * - \ref SCIP_STAGE_SOLVING
3249  * - \ref SCIP_STAGE_SOLVED
3250  */
3252  SCIP* scip, /**< SCIP data structure */
3253  FILE* file /**< output file */
3254  )
3255 {
3256  assert(scip != NULL);
3257  assert(scip->stat != NULL);
3258 
3259  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintNLPStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3260 
3261  if( scip->nlp == NULL )
3262  return;
3263 
3264  SCIPmessageFPrintInfo(scip->messagehdlr, file, "NLP : Time Calls\n");
3265 
3266  SCIPmessageFPrintInfo(scip->messagehdlr, file, " all NLPs : %10.2f %10" SCIP_LONGINT_FORMAT "\n",
3268  scip->stat->nnlps);
3269 }
3270 
3271 /** outputs relaxator statistics
3272  *
3273  * @pre This method can be called if SCIP is in one of the following stages:
3274  * - \ref SCIP_STAGE_SOLVING
3275  * - \ref SCIP_STAGE_SOLVED
3276  */
3278  SCIP* scip, /**< SCIP data structure */
3279  FILE* file /**< output file */
3280  )
3281 {
3282  int i;
3283 
3284  assert(scip != NULL);
3285  assert(scip->set != NULL);
3286 
3287  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintRelaxatorStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3288 
3289  if( scip->set->nrelaxs == 0 )
3290  return;
3291 
3292  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Relaxators : Time Calls\n");
3293 
3294  /* sort relaxators w.r.t. their name */
3295  SCIPsetSortRelaxsName(scip->set);
3296 
3297  for( i = 0; i < scip->set->nrelaxs; ++i )
3298  {
3299  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s: %10.2f %10" SCIP_LONGINT_FORMAT "\n",
3300  SCIPrelaxGetName(scip->set->relaxs[i]),
3301  SCIPrelaxGetTime(scip->set->relaxs[i]),
3302  SCIPrelaxGetNCalls(scip->set->relaxs[i]));
3303  }
3304 }
3305 
3306 /** outputs tree statistics
3307  *
3308  * @pre This method can be called if SCIP is in one of the following stages:
3309  * - \ref SCIP_STAGE_SOLVING
3310  * - \ref SCIP_STAGE_SOLVED
3311  */
3313  SCIP* scip, /**< SCIP data structure */
3314  FILE* file /**< output file */
3315  )
3316 {
3317  assert(scip != NULL);
3318  assert(scip->stat != NULL);
3319  assert(scip->tree != NULL);
3320 
3321  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintTreeStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3322 
3323  SCIPmessageFPrintInfo(scip->messagehdlr, file, "B&B Tree :\n");
3324  SCIPmessageFPrintInfo(scip->messagehdlr, file, " number of runs : %10d\n", scip->stat->nruns);
3325  SCIPmessageFPrintInfo(scip->messagehdlr, file,
3326  " nodes : %10" SCIP_LONGINT_FORMAT " (%" SCIP_LONGINT_FORMAT " internal, %" SCIP_LONGINT_FORMAT " leaves)\n",
3327  scip->stat->nnodes, scip->stat->ninternalnodes, scip->stat->nnodes - scip->stat->ninternalnodes );
3328  SCIPmessageFPrintInfo(scip->messagehdlr, file, " feasible leaves : %10d\n", scip->stat->nfeasleaves);
3329  SCIPmessageFPrintInfo(scip->messagehdlr, file, " infeas. leaves : %10d\n", scip->stat->ninfeasleaves);
3330  SCIPmessageFPrintInfo(scip->messagehdlr, file, " objective leaves : %10d\n", scip->stat->nobjleaves);
3331  SCIPmessageFPrintInfo(scip->messagehdlr, file,
3332  " nodes (total) : %10" SCIP_LONGINT_FORMAT " (%" SCIP_LONGINT_FORMAT " internal, %" SCIP_LONGINT_FORMAT " leaves)\n",
3334  SCIPmessageFPrintInfo(scip->messagehdlr, file, " nodes left : %10d\n", SCIPtreeGetNNodes(scip->tree));
3335  SCIPmessageFPrintInfo(scip->messagehdlr, file, " max depth : %10d\n", scip->stat->maxdepth);
3336  SCIPmessageFPrintInfo(scip->messagehdlr, file, " max depth (total): %10d\n", scip->stat->maxtotaldepth);
3337  SCIPmessageFPrintInfo(scip->messagehdlr, file, " backtracks : %10" SCIP_LONGINT_FORMAT " (%.1f%%)\n", scip->stat->nbacktracks,
3338  scip->stat->nnodes > 0 ? 100.0 * (SCIP_Real)scip->stat->nbacktracks / (SCIP_Real)scip->stat->nnodes : 0.0);
3339  SCIPmessageFPrintInfo(scip->messagehdlr, file, " early backtracks : %10" SCIP_LONGINT_FORMAT " (%.1f%%)\n", scip->stat->nearlybacktracks,
3340  scip->stat->nbacktracks > 0 ? 100.0 * (SCIP_Real)scip->stat->nearlybacktracks / (SCIP_Real)scip->stat->nbacktracks : 0.0);
3341  SCIPmessageFPrintInfo(scip->messagehdlr, file, " nodes exc. ref. : %10" SCIP_LONGINT_FORMAT " (%.1f%%)\n", scip->stat->nnodesaboverefbound,
3342  scip->stat->nnodes > 0 ? 100.0 * (SCIP_Real)scip->stat->nnodesaboverefbound / (SCIP_Real)scip->stat->nnodes : 0.0);
3343 
3344  SCIPmessageFPrintInfo(scip->messagehdlr, file, " delayed cutoffs : %10" SCIP_LONGINT_FORMAT "\n", scip->stat->ndelayedcutoffs);
3345  SCIPmessageFPrintInfo(scip->messagehdlr, file, " repropagations : %10" SCIP_LONGINT_FORMAT " (%" SCIP_LONGINT_FORMAT " domain reductions, %" SCIP_LONGINT_FORMAT " cutoffs)\n",
3346  scip->stat->nreprops, scip->stat->nrepropboundchgs, scip->stat->nrepropcutoffs);
3347  SCIPmessageFPrintInfo(scip->messagehdlr, file, " avg switch length: %10.2f\n",
3348  scip->stat->nnodes > 0
3349  ? (SCIP_Real)(scip->stat->nactivatednodes + scip->stat->ndeactivatednodes) / (SCIP_Real)scip->stat->nnodes : 0.0);
3350  SCIPmessageFPrintInfo(scip->messagehdlr, file, " switching time : %10.2f\n", SCIPclockGetTime(scip->stat->nodeactivationtime));
3351 }
3352 
3353 /** outputs solution statistics
3354  *
3355  * @pre This method can be called if SCIP is in one of the following stages:
3356  * - \ref SCIP_STAGE_PRESOLVING
3357  * - \ref SCIP_STAGE_EXITPRESOLVE
3358  * - \ref SCIP_STAGE_PRESOLVED
3359  * - \ref SCIP_STAGE_SOLVING
3360  * - \ref SCIP_STAGE_SOLVED
3361  */
3363  SCIP* scip, /**< SCIP data structure */
3364  FILE* file /**< output file */
3365  )
3366 {
3367  SCIP_Real primalbound;
3368  SCIP_Real dualbound;
3369  SCIP_Real bestsol;
3370  SCIP_Real gap;
3371  SCIP_Real firstprimalbound;
3372  SCIP_Bool objlimitreached;
3373  char limsolstring[SCIP_MAXSTRLEN];
3374 
3375  assert(scip != NULL);
3376  assert(scip->stat != NULL);
3377  assert(scip->primal != NULL);
3378 
3379  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintSolutionStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3380 
3381  primalbound = SCIPgetPrimalbound(scip);
3382  dualbound = SCIPgetDualbound(scip);
3383  gap = SCIPgetGap(scip);
3384 
3385  objlimitreached = FALSE;
3386  if( SCIPgetStage(scip) == SCIP_STAGE_SOLVED && scip->primal->nlimsolsfound == 0
3387  && !SCIPisInfinity(scip, primalbound) )
3388  objlimitreached = TRUE;
3389 
3390  if( scip->primal->nsolsfound != scip->primal->nlimsolsfound )
3391  (void) SCIPsnprintf(limsolstring, SCIP_MAXSTRLEN, ", %" SCIP_LONGINT_FORMAT " respecting the objective limit", scip->primal->nlimsolsfound);
3392  else
3393  limsolstring[0] = '\0';
3394 
3395  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Solution :\n");
3396  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Solutions found : %10" SCIP_LONGINT_FORMAT " (%" SCIP_LONGINT_FORMAT " improvements%s)\n",
3397  scip->primal->nsolsfound, scip->primal->nbestsolsfound, limsolstring);
3398 
3399  if( objlimitreached || SCIPsetIsInfinity(scip->set, REALABS(primalbound)) )
3400  {
3401  if( scip->set->stage == SCIP_STAGE_SOLVED )
3402  {
3403  if( scip->primal->nlimsolsfound == 0 )
3404  {
3405  if( SCIPgetStatus(scip) == SCIP_STATUS_INFORUNBD )
3406  {
3407  assert(!objlimitreached);
3408  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Primal Bound : infeasible or unbounded\n");
3409  }
3410  else
3411  {
3412  assert(SCIPgetStatus(scip) == SCIP_STATUS_INFEASIBLE);
3413  if( objlimitreached )
3414  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Primal Bound : infeasible (objective limit reached)\n");
3415  else
3416  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Primal Bound : infeasible\n");
3417  }
3418  }
3419  else
3420  {
3421  assert(!objlimitreached);
3422  assert(SCIPgetStatus(scip) == SCIP_STATUS_UNBOUNDED);
3423  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Primal Bound : unbounded\n");
3424  }
3425  }
3426  else
3427  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Primal Bound : -\n");
3428  }
3429  else
3430  {
3431  if( scip->primal->nlimsolsfound == 0 )
3432  {
3433  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Primal Bound : %+21.14e", primalbound);
3434  SCIPmessageFPrintInfo(scip->messagehdlr, file, " (user objective limit)\n");
3435  }
3436  else
3437  {
3438  /* display first primal bound line */
3439  firstprimalbound = scip->stat->firstprimalbound;
3440  SCIPmessageFPrintInfo(scip->messagehdlr, file, " First Solution : %+21.14e", firstprimalbound);
3441 
3442  SCIPmessageFPrintInfo(scip->messagehdlr, file, " (in run %d, after %" SCIP_LONGINT_FORMAT " nodes, %.2f seconds, depth %d, found by <%s>)\n",
3443  scip->stat->nrunsbeforefirst,
3444  scip->stat->nnodesbeforefirst,
3445  scip->stat->firstprimaltime,
3446  scip->stat->firstprimaldepth,
3447  ( scip->stat->firstprimalheur != NULL )
3448  ? ( SCIPheurGetName(scip->stat->firstprimalheur) )
3449  : (( scip->stat->nrunsbeforefirst == 0 ) ? "initial" : "relaxation"));
3450 
3451  if( SCIPisInfinity(scip, scip->stat->firstsolgap) )
3452  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Gap First Sol. : infinite\n");
3453  else
3454  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Gap First Sol. : %10.2f %%\n", 100.0 * scip->stat->firstsolgap);
3455 
3456  if( SCIPisInfinity(scip, scip->stat->lastsolgap) )
3457  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Gap Last Sol. : infinite\n");
3458  else
3459  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Gap Last Sol. : %10.2f %%\n", 100.0 * scip->stat->lastsolgap);
3460 
3461  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Primal Bound : %+21.14e", primalbound);
3462 
3463  /* display (best) primal bound */
3464  bestsol = SCIPsolGetObj(scip->primal->sols[0], scip->set, scip->transprob, scip->origprob);
3465  bestsol = SCIPretransformObj(scip, bestsol);
3466  if( SCIPsetIsGT(scip->set, bestsol, primalbound) )
3467  {
3468  SCIPmessageFPrintInfo(scip->messagehdlr, file, " (user objective limit)\n");
3469  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Best Solution : %+21.14e", bestsol);
3470  }
3471  SCIPmessageFPrintInfo(scip->messagehdlr, file, " (in run %d, after %" SCIP_LONGINT_FORMAT " nodes, %.2f seconds, depth %d, found by <%s>)\n",
3472  SCIPsolGetRunnum(scip->primal->sols[0]),
3473  SCIPsolGetNodenum(scip->primal->sols[0]),
3474  SCIPsolGetTime(scip->primal->sols[0]),
3475  SCIPsolGetDepth(scip->primal->sols[0]),
3476  SCIPsolGetHeur(scip->primal->sols[0]) != NULL
3478  : (SCIPsolGetRunnum(scip->primal->sols[0]) == 0 ? "initial" : "relaxation"));
3479  }
3480  }
3481  if( objlimitreached || SCIPsetIsInfinity(scip->set, REALABS(dualbound)) )
3482  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Dual Bound : -\n");
3483  else
3484  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Dual Bound : %+21.14e\n", dualbound);
3485  if( SCIPsetIsInfinity(scip->set, gap) )
3486  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Gap : infinite\n");
3487  else
3488  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Gap : %10.2f %%\n", 100.0 * gap);
3489 
3490  if( scip->set->misc_calcintegral )
3491  {
3492  if( SCIPgetStatus(scip) == SCIP_STATUS_INFEASIBLE )
3493  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Avg. Gap : - (problem infeasible)\n");
3494  else
3495  {
3496  SCIP_Real avggap;
3497  SCIP_Real primaldualintegral;
3498 
3499  if( !SCIPisFeasZero(scip, SCIPgetSolvingTime(scip)) )
3500  {
3501  primaldualintegral = SCIPstatGetPrimalDualIntegral(scip->stat, scip->set, scip->transprob, scip->origprob);
3502  avggap = primaldualintegral/SCIPgetSolvingTime(scip);
3503  }
3504  else
3505  {
3506  avggap = 0.0;
3507  primaldualintegral = 0.0;
3508  }
3509 
3510  /* caution: this assert is non-deterministic since it depends on the solving time */
3511  assert(0.0 <= avggap && SCIPisLE(scip, avggap, 100.0));
3512 
3513  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Avg. Gap : %10.2f %% (%.2f primal-dual integral)\n",
3514  avggap, primaldualintegral);
3515  }
3516  }
3517  else
3518  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Avg. Gap : - (not evaluated)\n");
3519 }
3520 
3521 /** outputs concurrent solver statistics
3522  *
3523  * @pre This method can be called if SCIP is in one of the following stages:
3524  * - \ref SCIP_STAGE_TRANSFORMED
3525  * - \ref SCIP_STAGE_INITPRESOLVE
3526  * - \ref SCIP_STAGE_PRESOLVING
3527  * - \ref SCIP_STAGE_EXITPRESOLVE
3528  * - \ref SCIP_STAGE_PRESOLVED
3529  * - \ref SCIP_STAGE_SOLVING
3530  * - \ref SCIP_STAGE_SOLVED
3531  */
3533  SCIP* scip, /**< SCIP data structure */
3534  FILE* file /**< output file */
3535  )
3536 {
3537  SCIP_CONCSOLVER** concsolvers;
3538  int nconcsolvers;
3539  int i;
3540  int winner;
3541 
3542  assert(scip != NULL);
3543  assert(scip->set != NULL);
3544 
3545  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintConcsolverStatistics", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3546 
3548  return;
3549 
3550  nconcsolvers = SCIPgetNConcurrentSolvers(scip);
3551  concsolvers = SCIPgetConcurrentSolvers(scip);
3552  winner = SCIPsyncstoreGetWinner(scip->syncstore);
3553 
3554  if( nconcsolvers > 0 )
3555  {
3556  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Concurrent Solvers : SolvingTime SyncTime Nodes LP Iters SolsShared SolsRecvd TighterBnds TighterIntBnds\n");
3557  for( i = 0; i < nconcsolvers; ++i )
3558  {
3559  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %c%-16s: %11.2f %11.2f %11" SCIP_LONGINT_FORMAT " %11" SCIP_LONGINT_FORMAT "%11i %11i %11" SCIP_LONGINT_FORMAT " %14" SCIP_LONGINT_FORMAT "\n",
3560  winner == i ? '*' : ' ',
3561  SCIPconcsolverGetName(concsolvers[i]),
3562  SCIPconcsolverGetSolvingTime(concsolvers[i]),
3563  SCIPconcsolverGetSyncTime(concsolvers[i]),
3564  SCIPconcsolverGetNNodes(concsolvers[i]),
3565  SCIPconcsolverGetNLPIterations(concsolvers[i]),
3566  SCIPconcsolverGetNSolsShared(concsolvers[i]),
3567  SCIPconcsolverGetNSolsRecvd(concsolvers[i]),
3568  SCIPconcsolverGetNTighterBnds(concsolvers[i]),
3569  SCIPconcsolverGetNTighterIntBnds(concsolvers[i])
3570  );
3571  }
3572  }
3573 }
3574 
3575 /** display Benders' decomposition statistics */
3577  SCIP* scip, /**< SCIP data structure */
3578  FILE* file /**< output file */
3579  )
3580 {
3581  SCIP_BENDERS** benders;
3582  int nbenders;
3583  int i;
3584 
3585  assert(scip != NULL);
3586  assert(scip->set != NULL);
3587 
3588  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintBendersStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3589 
3590  if( SCIPgetNActiveBenders(scip) == 0 )
3591  return;
3592 
3593  nbenders = SCIPgetNBenders(scip);
3594  benders = SCIPgetBenders(scip);
3595 
3596  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Benders Decomp : ExecTime SetupTime Calls Found Transfer\n");
3597  for( i = 0; i < nbenders; ++i )
3598  {
3599  if( SCIPbendersIsActive(benders[i]) )
3600  {
3601  SCIP_BENDERSCUT** benderscuts;
3602  int nbenderscuts;
3603  int j;
3604 
3605  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s: %10.2f %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT "\n",
3606  SCIPbendersGetName(scip->set->benders[i]),
3607  SCIPbendersGetTime(scip->set->benders[i]),
3608  SCIPbendersGetSetupTime(scip->set->benders[i]),
3609  SCIPbendersGetNCalls(scip->set->benders[i]),
3612 
3613  nbenderscuts = SCIPbendersGetNBenderscuts(scip->set->benders[i]);
3614  benderscuts = SCIPbendersGetBenderscuts(scip->set->benders[i]);
3615 
3616  for( j = 0; j < nbenderscuts; j++ )
3617  {
3618  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-15.17s: %10.2f %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " -\n",
3619  SCIPbenderscutGetName(benderscuts[j]),
3620  SCIPbenderscutGetTime(benderscuts[j]),
3621  SCIPbenderscutGetSetupTime(benderscuts[j]),
3622  SCIPbenderscutGetNCalls(benderscuts[j]),
3623  SCIPbenderscutGetNFound(benderscuts[j]));
3624  }
3625  }
3626  }
3627 }
3628 
3629 /** outputs root statistics
3630  *
3631  * @pre This method can be called if SCIP is in one of the following stages:
3632  * - \ref SCIP_STAGE_SOLVING
3633  * - \ref SCIP_STAGE_SOLVED
3634  */
3636  SCIP* scip, /**< SCIP data structure */
3637  FILE* file /**< output file */
3638  )
3639 {
3640  SCIP_Real dualboundroot;
3641  SCIP_Real firstdualboundroot;
3642  SCIP_Real firstlptime;
3643  SCIP_Real firstlpspeed;
3644 
3645  assert(scip != NULL);
3646  assert(scip->stat != NULL);
3647  assert(scip->primal != NULL);
3648 
3649  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintRootStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3650 
3651  dualboundroot = SCIPgetDualboundRoot(scip);
3652  firstdualboundroot = SCIPgetFirstLPDualboundRoot(scip);
3653  firstlptime = SCIPgetFirstLPTime(scip);
3654 
3655  if( firstlptime > 0.0 )
3656  firstlpspeed = (SCIP_Real)scip->stat->nrootfirstlpiterations/firstlptime;
3657  else
3658  firstlpspeed = 0.0;
3659 
3660  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Root Node :\n");
3661  if( SCIPsetIsInfinity(scip->set, REALABS(firstdualboundroot)) )
3662  SCIPmessageFPrintInfo(scip->messagehdlr, file, " First LP value : -\n");
3663  else
3664  SCIPmessageFPrintInfo(scip->messagehdlr, file, " First LP value : %+21.14e\n", firstdualboundroot);
3665  if( firstlpspeed > 0.0 )
3666  SCIPmessageFPrintInfo(scip->messagehdlr, file, " First LP Iters : %10" SCIP_LONGINT_FORMAT " (%.2f Iter/sec)\n",
3668  (SCIP_Real)scip->stat->nrootfirstlpiterations/firstlptime);
3669  else
3670  SCIPmessageFPrintInfo(scip->messagehdlr, file, " First LP Iters : %10" SCIP_LONGINT_FORMAT "\n", scip->stat->nrootfirstlpiterations);
3671  SCIPmessageFPrintInfo(scip->messagehdlr, file, " First LP Time : %10.2f\n", firstlptime);
3672 
3673  if( SCIPsetIsInfinity(scip->set, REALABS(dualboundroot)) )
3674  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Final Dual Bound : -\n");
3675  else
3676  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Final Dual Bound : %+21.14e\n", dualboundroot);
3677  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Final Root Iters : %10" SCIP_LONGINT_FORMAT "\n", scip->stat->nrootlpiterations);
3678 
3679  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Root LP Estimate : ");
3680  if( scip->stat->rootlpbestestimate != SCIP_INVALID ) /*lint !e777*/
3681  {
3682  SCIPmessageFPrintInfo(scip->messagehdlr, file, "%+21.14e\n", SCIPretransformObj(scip, scip->stat->rootlpbestestimate));
3683  }
3684  else
3685  SCIPmessageFPrintInfo(scip->messagehdlr, file, "%21s\n","-");
3686 }
3687 
3688 /** outputs timing statistics
3689  *
3690  * @pre This method can be called if SCIP is in one of the following stages:
3691  * - \ref SCIP_STAGE_PROBLEM
3692  * - \ref SCIP_STAGE_TRANSFORMED
3693  * - \ref SCIP_STAGE_INITPRESOLVE
3694  * - \ref SCIP_STAGE_PRESOLVING
3695  * - \ref SCIP_STAGE_EXITPRESOLVE
3696  * - \ref SCIP_STAGE_PRESOLVED
3697  * - \ref SCIP_STAGE_SOLVING
3698  * - \ref SCIP_STAGE_SOLVED
3699  */
3701  SCIP* scip, /**< SCIP data structure */
3702  FILE* file /**< output file */
3703  )
3704 {
3705  SCIP_Real readingtime;
3706 
3707  assert(scip != NULL);
3708  assert(scip->set != NULL);
3709 
3710  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintTimingStatistics", FALSE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3711 
3712  readingtime = SCIPgetReadingTime(scip);
3713 
3714  if( SCIPgetStage(scip) == SCIP_STAGE_PROBLEM )
3715  {
3716  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Total Time : %10.2f\n", readingtime);
3717  SCIPmessageFPrintInfo(scip->messagehdlr, file, " reading : %10.2f\n", readingtime);
3718  }
3719  else
3720  {
3721  SCIP_Real totaltime;
3722  SCIP_Real solvingtime;
3723 
3724  solvingtime = SCIPclockGetTime(scip->stat->solvingtime);
3725 
3726  if( scip->set->time_reading )
3727  totaltime = solvingtime;
3728  else
3729  totaltime = solvingtime + readingtime;
3730 
3731  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Total Time : %10.2f\n", totaltime);
3732  SCIPmessageFPrintInfo(scip->messagehdlr, file, " solving : %10.2f\n", solvingtime);
3733  SCIPmessageFPrintInfo(scip->messagehdlr, file, " presolving : %10.2f (included in solving)\n", SCIPclockGetTime(scip->stat->presolvingtime));
3734  SCIPmessageFPrintInfo(scip->messagehdlr, file, " reading : %10.2f%s\n", readingtime, scip->set->time_reading ? " (included in solving)" : "");
3735 
3736  if( scip->stat->ncopies > 0 )
3737  {
3738  SCIP_Real copytime;
3739 
3740  copytime = SCIPclockGetTime(scip->stat->copyclock);
3741 
3742  SCIPmessageFPrintInfo(scip->messagehdlr, file, " copying : %10.2f (%d #copies) (minimal %.2f, maximal %.2f, average %.2f)\n",
3743  copytime, scip->stat->ncopies, scip->stat->mincopytime, scip->stat->maxcopytime, copytime / scip->stat->ncopies);
3744  }
3745  else
3746  SCIPmessageFPrintInfo(scip->messagehdlr, file, " copying : %10.2f %s\n", 0.0, "(0 times copied the problem)");
3747  }
3748 }
3749 
3750 /** comparison method for statistics tables */
3751 static
3753 { /*lint --e{715}*/
3754  return (SCIPtableGetPosition((SCIP_TABLE*)elem1) - (SCIPtableGetPosition((SCIP_TABLE*)elem2)));
3755 }
3756 
3757 /** outputs solving statistics
3758  *
3759  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3760  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3761  *
3762  * @note If limits have been changed between the solution and the call to this function, the status is recomputed and
3763  * thus may to correspond to the original status.
3764  *
3765  * @pre This method can be called if SCIP is in one of the following stages:
3766  * - \ref SCIP_STAGE_INIT
3767  * - \ref SCIP_STAGE_PROBLEM
3768  * - \ref SCIP_STAGE_TRANSFORMED
3769  * - \ref SCIP_STAGE_INITPRESOLVE
3770  * - \ref SCIP_STAGE_PRESOLVING
3771  * - \ref SCIP_STAGE_EXITPRESOLVE
3772  * - \ref SCIP_STAGE_PRESOLVED
3773  * - \ref SCIP_STAGE_SOLVING
3774  * - \ref SCIP_STAGE_SOLVED
3775  */
3777  SCIP* scip, /**< SCIP data structure */
3778  FILE* file /**< output file (or NULL for standard output) */
3779  )
3780 {
3781  SCIP_TABLE** tables;
3782  int ntables;
3783  int i;
3784 
3785  assert(scip != NULL);
3786  assert(scip->set != NULL);
3787 
3788  SCIP_CALL( SCIPcheckStage(scip, "SCIPprintStatistics", TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3789 
3790  ntables = SCIPgetNTables(scip);
3791  tables = SCIPgetTables(scip);
3792 
3793  /* sort all tables by position unless this has already been done */
3794  if( ! scip->set->tablessorted )
3795  {
3796  SCIPsortPtr((void**)tables, tablePosComp, ntables);
3797 
3798  scip->set->tablessorted = TRUE;
3799  }
3800 
3801  for( i = 0; i < ntables; ++i )
3802  {
3803  /* skip tables which are not active or only used in later stages */
3804  if( ( ! SCIPtableIsActive(tables[i]) ) || SCIPtableGetEarliestStage(tables[i]) > SCIPgetStage(scip) )
3805  continue;
3806 
3807  SCIP_CALL( SCIPtableOutput(tables[i], scip->set, file) );
3808  }
3809 
3810  return SCIP_OKAY;
3811 }
3812 
3813 /** outputs reoptimization statistics
3814  *
3815  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3816  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3817  *
3818  * @pre This method can be called if SCIP is in one of the following stages:
3819  * - \ref SCIP_STAGE_INIT
3820  * - \ref SCIP_STAGE_PROBLEM
3821  * - \ref SCIP_STAGE_TRANSFORMED
3822  * - \ref SCIP_STAGE_INITPRESOLVE
3823  * - \ref SCIP_STAGE_PRESOLVING
3824  * - \ref SCIP_STAGE_EXITPRESOLVE
3825  * - \ref SCIP_STAGE_PRESOLVED
3826  * - \ref SCIP_STAGE_SOLVING
3827  * - \ref SCIP_STAGE_SOLVED
3828  */
3830  SCIP* scip, /**< SCIP data structure */
3831  FILE* file /**< output file (or NULL for standard output) */
3832  )
3833 {
3834  SCIP_Real solving;
3835  SCIP_Real presolving;
3836  SCIP_Real updatetime;
3837 
3838  SCIP_CALL( SCIPcheckStage(scip, "SCIPprintReoptStatistics", TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3839 
3840  /* skip if reoptimization is disabled */
3841  if( !scip->set->reopt_enable )
3842  return SCIP_OKAY;
3843 
3844  solving = SCIPclockGetTime(scip->stat->solvingtimeoverall);
3845  presolving = SCIPclockGetTime(scip->stat->presolvingtimeoverall);
3846  updatetime = SCIPclockGetTime(scip->stat->reoptupdatetime);
3847 
3848  SCIPmessageFPrintInfo(scip->messagehdlr, file, "SCIP Reopt Status : finish after %d runs.\n", scip->stat->nreoptruns);
3849  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Time (sec) :\n");
3850  SCIPmessageFPrintInfo(scip->messagehdlr, file, " solving : %10.2f\n", solving);
3851  SCIPmessageFPrintInfo(scip->messagehdlr, file, " presolving : %10.2f (included in solving)\n", presolving);
3852  SCIPmessageFPrintInfo(scip->messagehdlr, file, " save time : %10.2f\n", SCIPreoptGetSavingtime(scip->reopt));
3853  SCIPmessageFPrintInfo(scip->messagehdlr, file, " update time : %10.2f\n", updatetime);
3854  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Nodes : feas infeas pruned cutoff\n");
3855  SCIPmessageFPrintInfo(scip->messagehdlr, file, " total : %10d %10d %10d %10d\n",
3858  SCIPmessageFPrintInfo(scip->messagehdlr, file, " avg : %10.2f %10.2f %10.2f %10.2f\n",
3863 
3864  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Restarts : global local\n");
3865  SCIPmessageFPrintInfo(scip->messagehdlr, file, " first : %10d --\n", SCIPreoptGetFirstRestarts(scip->reopt));
3866  SCIPmessageFPrintInfo(scip->messagehdlr, file, " last : %10d --\n", SCIPreoptGetLastRestarts(scip->reopt));
3867  SCIPmessageFPrintInfo(scip->messagehdlr, file, " total : %10d %10d\n", SCIPreoptGetNRestartsGlobal(scip->reopt),
3869  SCIPmessageFPrintInfo(scip->messagehdlr, file, " avg : -- %10.2f\n",
3871 
3872  return SCIP_OKAY;
3873 }
3874 
3875 /** outputs history statistics about branchings on variables
3876  *
3877  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3878  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3879  *
3880  * @pre This method can be called if SCIP is in one of the following stages:
3881  * - \ref SCIP_STAGE_INIT
3882  * - \ref SCIP_STAGE_PROBLEM
3883  * - \ref SCIP_STAGE_TRANSFORMED
3884  * - \ref SCIP_STAGE_INITPRESOLVE
3885  * - \ref SCIP_STAGE_PRESOLVING
3886  * - \ref SCIP_STAGE_EXITPRESOLVE
3887  * - \ref SCIP_STAGE_PRESOLVED
3888  * - \ref SCIP_STAGE_SOLVING
3889  * - \ref SCIP_STAGE_SOLVED
3890  */
3892  SCIP* scip, /**< SCIP data structure */
3893  FILE* file /**< output file (or NULL for standard output) */
3894  )
3895 {
3896  SCIP_VAR** vars;
3897  int totalnstrongbranchs;
3898  int v;
3899 
3900  SCIP_CALL( SCIPcheckStage(scip, "SCIPprintBranchingStatistics", TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3901 
3902  switch( scip->set->stage )
3903  {
3904  case SCIP_STAGE_INIT:
3905  case SCIP_STAGE_PROBLEM:
3906  SCIPmessageFPrintInfo(scip->messagehdlr, file, "problem not yet solved. branching statistics not available.\n");
3907  return SCIP_OKAY;
3908 
3911  case SCIP_STAGE_PRESOLVING:
3913  case SCIP_STAGE_PRESOLVED:
3914  case SCIP_STAGE_SOLVING:
3915  case SCIP_STAGE_SOLVED:
3916  SCIP_CALL( SCIPallocBufferArray(scip, &vars, scip->transprob->nvars) );
3917  for( v = 0; v < scip->transprob->nvars; ++v )
3918  {
3919  SCIP_VAR* var;
3920  int i;
3921 
3922  var = scip->transprob->vars[v];
3923  for( i = v; i > 0 && strcmp(SCIPvarGetName(var), SCIPvarGetName(vars[i-1])) < 0; i-- )
3924  vars[i] = vars[i-1];
3925  vars[i] = var;
3926  }
3927 
3928  SCIPmessageFPrintInfo(scip->messagehdlr, file, " locks branchings inferences cutoffs LP gain pscostcount gain variance \n");
3929  SCIPmessageFPrintInfo(scip->messagehdlr, file, "variable prio factor down up depth down up sb down up down up down up down up down up\n");
3930 
3931  totalnstrongbranchs = 0;
3932  for( v = 0; v < scip->transprob->nvars; ++v )
3933  {
3936  || SCIPgetVarNStrongbranchs(scip, vars[v]) > 0 )
3937  {
3938  int nstrongbranchs;
3939 
3940  nstrongbranchs = SCIPgetVarNStrongbranchs(scip, vars[v]);
3941  totalnstrongbranchs += nstrongbranchs;
3942  SCIPmessageFPrintInfo(scip->messagehdlr, file, "%-16s %5d %8.1f %6d %6d %6.1f %7" SCIP_LONGINT_FORMAT " %7" SCIP_LONGINT_FORMAT " %5d %8.1f %8.1f %5.1f%% %5.1f%% %15.4f %15.4f %7.1f %7.1f %15.2f %15.2f\n",
3943  SCIPvarGetName(vars[v]),
3944  SCIPvarGetBranchPriority(vars[v]),
3945  SCIPvarGetBranchFactor(vars[v]),
3949  + SCIPvarGetAvgBranchdepth(vars[v], SCIP_BRANCHDIR_UPWARDS))/2.0 - 1.0,
3952  nstrongbranchs,
3955  100.0 * SCIPvarGetAvgCutoffs(vars[v], scip->stat, SCIP_BRANCHDIR_DOWNWARDS),
3956  100.0 * SCIPvarGetAvgCutoffs(vars[v], scip->stat, SCIP_BRANCHDIR_UPWARDS),
3957  SCIPvarGetPseudocost(vars[v], scip->stat, -1.0),
3958  SCIPvarGetPseudocost(vars[v], scip->stat, +1.0),
3963  }
3964  }
3965  SCIPmessageFPrintInfo(scip->messagehdlr, file, "total %7" SCIP_LONGINT_FORMAT " %7" SCIP_LONGINT_FORMAT " %5d %8.1f %8.1f %5.1f%% %5.1f%% %15.4f %15.4f %7.1f %7.1f %15.2f %15.2f\n",
3968  totalnstrongbranchs,
3987 
3988  SCIPfreeBufferArray(scip, &vars);
3989 
3990  return SCIP_OKAY;
3991 
3992  default:
3993  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
3994  return SCIP_INVALIDCALL;
3995  } /*lint !e788*/
3996 }
3997 
3998 /** outputs node information display line
3999  *
4000  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4001  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4002  *
4003  * @pre This method can be called if SCIP is in one of the following stages:
4004  * - \ref SCIP_STAGE_SOLVING
4005  */
4007  SCIP* scip, /**< SCIP data structure */
4008  FILE* file, /**< output file (or NULL for standard output) */
4009  SCIP_VERBLEVEL verblevel, /**< minimal verbosity level to actually display the information line */
4010  SCIP_Bool endline /**< should the line be terminated with a newline symbol? */
4011  )
4012 {
4013  SCIP_CALL( SCIPcheckStage(scip, "SCIPprintDisplayLine", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
4014 
4015  if( (SCIP_VERBLEVEL)scip->set->disp_verblevel >= verblevel )
4016  {
4017  SCIP_CALL( SCIPdispPrintLine(scip->set, scip->messagehdlr, scip->stat, file, TRUE, endline) );
4018  }
4019 
4020  return SCIP_OKAY;
4021 }
4022 
4023 /** gets total number of implications between variables that are stored in the implication graph
4024  *
4025  * @return the total number of implications between variables that are stored in the implication graph
4026  *
4027  * @pre This method can be called if SCIP is in one of the following stages:
4028  * - \ref SCIP_STAGE_INITPRESOLVE
4029  * - \ref SCIP_STAGE_PRESOLVING
4030  * - \ref SCIP_STAGE_EXITPRESOLVE
4031  * - \ref SCIP_STAGE_PRESOLVED
4032  * - \ref SCIP_STAGE_INITSOLVE
4033  * - \ref SCIP_STAGE_SOLVING
4034  * - \ref SCIP_STAGE_SOLVED
4035  */
4037  SCIP* scip /**< SCIP data structure */
4038  )
4039 {
4040  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNImplications", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
4041 
4042  return scip->stat->nimplications;
4043 }
4044 
4045 /** stores conflict graph of binary variables' implications into a file, which can be used as input for the DOT tool
4046  *
4047  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4048  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4049  *
4050  * @pre This method can be called if SCIP is in one of the following stages:
4051  * - \ref SCIP_STAGE_TRANSFORMED
4052  * - \ref SCIP_STAGE_INITPRESOLVE
4053  * - \ref SCIP_STAGE_PRESOLVING
4054  * - \ref SCIP_STAGE_EXITPRESOLVE
4055  * - \ref SCIP_STAGE_PRESOLVED
4056  * - \ref SCIP_STAGE_INITSOLVE
4057  * - \ref SCIP_STAGE_SOLVING
4058  * - \ref SCIP_STAGE_SOLVED
4059  * - \ref SCIP_STAGE_EXITSOLVE
4060  *
4061  * @deprecated because binary implications are now stored as cliques, please use SCIPwriteCliqueGraph() instead
4062  *
4063  */
4065  SCIP* scip, /**< SCIP data structure */
4066  const char* filename /**< file name, or NULL for stdout */
4067  )
4068 { /*lint --e{715}*/
4069  SCIPwarningMessage(scip, "SCIPwriteImplicationConflictGraph() is deprecated and does not do anything anymore. All binary to binary implications are now stored in the clique data structure, which can be written to a GML formatted file via SCIPwriteCliqueGraph().\n");
4070 
4071  return SCIP_OKAY;
4072 }
4073 
4074 /** update statistical information when a new solution was found */
4076  SCIP* scip /**< SCIP data structure */
4077  )
4078 {
4080 
4081  if( scip->primal->nsols == 1 )
4082  scip->stat->firstsolgap = scip->stat->lastsolgap;
4083 
4084  if( scip->set->stage == SCIP_STAGE_SOLVING && scip->set->misc_calcintegral )
4085  {
4087  }
4088 }
enum SCIP_Result SCIP_RESULT
Definition: type_result.h:52
SCIP_Real SCIPhistoryGetAvgConflictlength(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
Definition: history.c:554
SCIP_Real cutoffbound
Definition: struct_primal.h:46
SCIP_RETCODE SCIPprintReoptStatistics(SCIP *scip, FILE *file)
SCIP_Longint nlexduallps
Definition: struct_stat.h:182
internal methods for separators
int SCIPbendersGetNBenderscuts(SCIP_BENDERS *benders)
Definition: benders.c:4838
SCIP_Longint nprimallps
Definition: struct_stat.h:178
SCIP_Longint SCIPconflictGetNStrongbranchSuccess(SCIP_CONFLICT *conflict)
Definition: conflict.c:8681
SCIP_STAT * stat
Definition: struct_scip.h:69
void SCIPsetSortPropsName(SCIP_SET *set)
Definition: set.c:4272
SCIP_Real SCIPgetAvgPseudocostCountCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)
SCIP_Real SCIPgetFirstPrimalBound(SCIP *scip)
SCIP_Longint ndualresolvelpiterations
Definition: struct_stat.h:61
SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)
SCIP_Longint SCIPconflictGetNLocalChgBds(SCIP_CONFLICT *conflict)
Definition: conflict.c:3598
SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)
Definition: set.c:5953
SCIP_Longint ninfeasleaves
Definition: struct_stat.h:77
const char * SCIPbenderscutGetName(SCIP_BENDERSCUT *benderscut)
Definition: benderscut.c:489
int SCIPpresolGetNDelConss(SCIP_PRESOL *presol)
Definition: presol.c:757
SCIP_Real SCIPgetSolvingTime(SCIP *scip)
Definition: scip_timing.c:436
SCIP_Longint SCIPgetNRootLPIterations(SCIP *scip)
void SCIPprintSeparatorStatistics(SCIP *scip, FILE *file)
SCIP_Real firstlpdualbound
Definition: struct_stat.h:118
SCIP_Real SCIPgetAvgPseudocostScoreCurrentRun(SCIP *scip)
#define NULL
Definition: def.h:239
internal methods for managing events
SCIP_Longint SCIPconflictGetNPropConflictConss(SCIP_CONFLICT *conflict)
Definition: conflict.c:5533
SCIP_READER ** readers
Definition: struct_set.h:68
int SCIPdivesetGetMinSolutionDepth(SCIP_DIVESET *diveset)
Definition: heur.c:438
default message handler
SCIP_Longint nnodelpiterations
Definition: struct_stat.h:63
SCIP_Real SCIPheurGetSetupTime(SCIP_HEUR *heur)
Definition: heur.c:1432
SCIP_Longint nlpsolsfound
Definition: struct_stat.h:92
trivialnegation primal heuristic
internal methods for storing primal CIP solutions
int SCIPpresolGetNAggrVars(SCIP_PRESOL *presol)
Definition: presol.c:717
SCIP_Longint nlpiterations
Definition: struct_stat.h:53
const char * SCIPpricerGetName(SCIP_PRICER *pricer)
Definition: pricer.c:588
int SCIPvarGetNLocksDownType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
Definition: var.c:3176
public methods for branching and inference history structure
void SCIPprintConstraintStatistics(SCIP *scip, FILE *file)
SCIP_STAGE SCIPgetStage(SCIP *scip)
Definition: scip_general.c:412
SCIP_Real SCIPgetFirstLPLowerboundRoot(SCIP *scip)
methods to interpret (evaluate) an expression tree "fast"
internal methods for branch and bound tree
SCIP_Longint SCIPgetNLPIterations(SCIP *scip)
SCIP_Longint nfeasleaves
Definition: struct_stat.h:76
SCIP_CONFLICT * conflict
Definition: struct_scip.h:85
SCIP_Bool SCIPtableIsActive(SCIP_TABLE *table)
Definition: table.c:339
SCIP_Longint ndeactivatednodes
Definition: struct_stat.h:84
SCIP_Real SCIPvarGetBranchFactor(SCIP_VAR *var)
Definition: var.c:17503
SCIP_Longint SCIPconflictGetNPropSuccess(SCIP_CONFLICT *conflict)
Definition: conflict.c:5523
SCIP_Real SCIPpropGetRespropTime(SCIP_PROP *prop)
Definition: prop.c:1066
SCIP_Longint SCIPdivesetGetNBacktracks(SCIP_DIVESET *diveset)
Definition: heur.c:488
int SCIPgetNConcurrentSolvers(SCIP *scip)
Definition: concurrent.c:107
public methods for memory management
int npricerounds
Definition: struct_stat.h:216
int SCIPpricestoreGetNVars(SCIP_PRICESTORE *pricestore)
Definition: pricestore.c:602
SCIP_Real SCIPgetDualboundRoot(SCIP *scip)
SCIP_Real SCIPgetReadingTime(SCIP *scip)
Definition: scip_timing.c:463
SCIP_Real SCIPgetCutoffbound(SCIP *scip)
SCIP_Real SCIPgetPrimalbound(SCIP *scip)
SCIP_Longint SCIPconflictGetNBoundexceedingLPConflictConss(SCIP_CONFLICT *conflict)
Definition: conflict.c:8307
int SCIPpricestoreGetNProbvarsFound(SCIP_PRICESTORE *pricestore)
Definition: pricestore.c:644
SCIP_Longint SCIPcutpoolGetNCutsFound(SCIP_CUTPOOL *cutpool)
Definition: cutpool.c:1093
SCIP_RETCODE SCIPdispPrintLine(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, FILE *file, SCIP_Bool forcedisplay, SCIP_Bool endline)
Definition: disp.c:405
SCIP_Longint nlps
Definition: struct_stat.h:176
methods for implications, variable bounds, and cliques
SCIP_Longint SCIPbranchruleGetNChildren(SCIP_BRANCHRULE *branchrule)
Definition: branch.c:2162
SCIP_Longint SCIPconflictGetNAppliedGlobalConss(SCIP_CONFLICT *conflict)
Definition: conflict.c:3578
SCIP_Longint SCIPconshdlrGetNDomredsFound(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4897
SCIP_Longint nbarrierlpiterations
Definition: struct_stat.h:59
SCIP_Real SCIPpricestoreGetProbPricingTime(SCIP_PRICESTORE *pricestore)
Definition: pricestore.c:624
SCIP_Real SCIPvarGetAvgBranchdepth(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:15260
SCIP_Longint SCIPpropGetNRespropCalls(SCIP_PROP *prop)
Definition: prop.c:1096
SCIP_Longint SCIPconflictGetNBoundexceedingLPIterations(SCIP_CONFLICT *conflict)
Definition: conflict.c:8347
SCIP_CLOCK * conflictlptime
Definition: struct_stat.h:155
int SCIPpropGetNChgSides(SCIP_PROP *prop)
Definition: prop.c:1246
int nrunsbeforefirst
Definition: struct_stat.h:254
SCIP_RETCODE SCIPupdateCutoffbound(SCIP *scip, SCIP_Real cutoffbound)
#define SCIP_MAXSTRLEN
Definition: def.h:260
SCIP_Longint SCIPconshdlrGetNCutoffs(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4837
int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
Definition: var.c:3233
SCIP_Longint SCIPheurGetNBestSolsFound(SCIP_HEUR *heur)
Definition: heur.c:1400
SCIP_Real rootlowerbound
Definition: struct_stat.h:119
const char * SCIPbendersGetName(SCIP_BENDERS *benders)
Definition: benders.c:4194
SCIP_Longint SCIPgetNSolsFound(SCIP *scip)
SCIP_Longint SCIPgetNBarrierLPs(SCIP *scip)
SCIP_Longint SCIPconflictGetNPseudoReconvergenceLiterals(SCIP_CONFLICT *conflict)
Definition: conflict.c:8958
internal methods for clocks and timing issues
SCIP_Longint ntotalnodes
Definition: struct_stat.h:78
SCIP_Longint SCIPcomprGetNFound(SCIP_COMPR *compr)
Definition: compr.c:510
SCIP_Longint SCIPconflictGetNGlobalChgBds(SCIP_CONFLICT *conflict)
Definition: conflict.c:3568
SCIP_Real SCIPcomprGetTime(SCIP_COMPR *compr)
Definition: compr.c:540
SCIP_Longint nrootfirstlpiterations
Definition: struct_stat.h:55
int nprops
Definition: struct_set.h:112
void SCIPprintConcsolverStatistics(SCIP *scip, FILE *file)
SCIP_Longint SCIPconflictGetNPseudoConflictLiterals(SCIP_CONFLICT *conflict)
Definition: conflict.c:8938
SCIP_Longint ndivinglps
Definition: struct_stat.h:190
SCIP_Longint SCIPconflictGetNInfeasibleLPSuccess(SCIP_CONFLICT *conflict)
Definition: conflict.c:8217
static SCIP_DECL_SORTPTRCOMP(tablePosComp)
void SCIPsetSortComprsName(SCIP_SET *set)
Definition: set.c:4551
SCIP_EVENTQUEUE * eventqueue
Definition: struct_scip.h:78
internal methods for NLPI solver interfaces
SCIP_Longint nsbtimesiterlimhit
Definition: struct_stat.h:112
SCIP_Longint SCIPconflictGetNPropCalls(SCIP_CONFLICT *conflict)
Definition: conflict.c:5513
SCIP_Longint SCIPconflictGetNDualrayInfSuccess(SCIP_CONFLICT *conflict)
Definition: conflict.c:8611
SCIP_Longint SCIPsepaGetNDomredsFound(SCIP_SEPA *sepa)
Definition: sepa.c:906
int nintvars
Definition: struct_prob.h:63
SCIP_Real SCIPgetAvgCutoffScoreCurrentRun(SCIP *scip)
public methods for timing
SCIP_Real SCIPpricerGetTime(SCIP_PRICER *pricer)
Definition: pricer.c:662
SCIP_PRIMAL * primal
Definition: struct_scip.h:83
SCIP_DIVESET ** SCIPheurGetDivesets(SCIP_HEUR *heur)
Definition: heur.c:1452
SCIP_Real SCIPgetAvgConflictScore(SCIP *scip)
SCIP_RETCODE SCIPprintTransProblem(SCIP *scip, FILE *file, const char *extension, SCIP_Bool genericnames)
SCIP_Real lastsolgap
Definition: struct_stat.h:124
SCIP_Longint SCIPconflictGetNStrongbranchIterations(SCIP_CONFLICT *conflict)
Definition: conflict.c:8731
SCIP_Longint nrootstrongbranchs
Definition: struct_stat.h:195
const char * SCIPreaderGetName(SCIP_READER *reader)
Definition: reader.c:547
SCIP_Longint SCIPgetNDualLPs(SCIP *scip)
interface methods for specific LP solvers
SCIP_Real SCIPsetInfinity(SCIP_SET *set)
Definition: set.c:5813
SCIP_Bool time_reading
Definition: struct_set.h:552
internal methods for displaying statistics tables
int nreoptruns
Definition: struct_stat.h:257
SCIP_SOL ** sols
Definition: struct_primal.h:48
int SCIPgetMaxDepth(SCIP *scip)
void SCIPprintStatusStatistics(SCIP *scip, FILE *file)
SCIP_Real SCIPbranchGetScore(SCIP_SET *set, SCIP_VAR *var, SCIP_Real downgain, SCIP_Real upgain)
Definition: branch.c:2189
SCIP_Longint nstrongbranchs
Definition: struct_stat.h:194
SCIP_Longint SCIPpropGetNCalls(SCIP_PROP *prop)
Definition: prop.c:1086
SCIP_RETCODE SCIPprintDisplayLine(SCIP *scip, FILE *file, SCIP_VERBLEVEL verblevel, SCIP_Bool endline)
SCIP_Real SCIPsepaGetSetupTime(SCIP_SEPA *sepa)
Definition: sepa.c:786