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