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-2022 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SCIP is distributed under the terms of the ZIB Academic License. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SCIP; see the file COPYING. If not visit scipopt.org. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file scip_solvingstats.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_cutsel.h"
57 #include "scip/pub_expr.h"
58 #include "scip/pub_heur.h"
59 #include "scip/pub_history.h"
60 #include "scip/pub_message.h"
61 #include "scip/pub_misc.h"
62 #include "scip/pub_misc_sort.h"
63 #include "scip/pub_nlpi.h"
64 #include "scip/pub_presol.h"
65 #include "scip/pub_pricer.h"
66 #include "scip/pub_prop.h"
67 #include "scip/pub_reader.h"
68 #include "scip/pub_relax.h"
69 #include "scip/pub_reopt.h"
70 #include "scip/pub_sepa.h"
71 #include "scip/pub_sol.h"
72 #include "scip/pub_table.h"
73 #include "scip/pub_var.h"
74 #include "scip/reader.h"
75 #include "scip/reopt.h"
76 #include "scip/scip_benders.h"
77 #include "scip/scip_general.h"
78 #include "scip/scip_mem.h"
79 #include "scip/scip_message.h"
80 #include "scip/scip_numerics.h"
81 #include "scip/scip_sol.h"
82 #include "scip/scip_solvingstats.h"
83 #include "scip/scip_table.h"
84 #include "scip/scip_timing.h"
85 #include "scip/scip_var.h"
86 #include "scip/sepastore.h"
87 #include "scip/set.h"
88 #include "scip/sol.h"
89 #include "scip/stat.h"
90 #include "scip/struct_mem.h"
91 #include "scip/struct_primal.h"
92 #include "scip/struct_prob.h"
93 #include "scip/struct_scip.h"
94 #include "scip/struct_set.h"
95 #include "scip/struct_stat.h"
96 #include "scip/syncstore.h"
97 #include "scip/table.h"
98 #include "scip/tree.h"
99 #include "scip/var.h"
100 #include <string.h>
101 
102 /** gets number of branch and bound runs performed, including the current run
103  *
104  * @return the number of branch and bound runs performed, including the current run
105  *
106  * @pre This method can be called if SCIP is in one of the following stages:
107  * - \ref SCIP_STAGE_PROBLEM
108  * - \ref SCIP_STAGE_TRANSFORMING
109  * - \ref SCIP_STAGE_TRANSFORMED
110  * - \ref SCIP_STAGE_INITPRESOLVE
111  * - \ref SCIP_STAGE_PRESOLVING
112  * - \ref SCIP_STAGE_EXITPRESOLVE
113  * - \ref SCIP_STAGE_PRESOLVED
114  * - \ref SCIP_STAGE_INITSOLVE
115  * - \ref SCIP_STAGE_SOLVING
116  * - \ref SCIP_STAGE_SOLVED
117  * - \ref SCIP_STAGE_EXITSOLVE
118  * - \ref SCIP_STAGE_FREETRANS
119  */
121  SCIP* scip /**< SCIP data structure */
122  )
123 {
124  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNRuns", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
125 
126  return scip->stat->nruns;
127 }
128 
129 /** gets number of reoptimization runs performed, including the current run
130  *
131  * @return the number of reoptimization runs performed, including the current run
132  *
133  * @pre This method can be called if SCIP is in one of the following stages:
134  * - \ref SCIP_STAGE_PROBLEM
135  * - \ref SCIP_STAGE_TRANSFORMING
136  * - \ref SCIP_STAGE_TRANSFORMED
137  * - \ref SCIP_STAGE_INITPRESOLVE
138  * - \ref SCIP_STAGE_PRESOLVING
139  * - \ref SCIP_STAGE_EXITPRESOLVE
140  * - \ref SCIP_STAGE_PRESOLVED
141  * - \ref SCIP_STAGE_INITSOLVE
142  * - \ref SCIP_STAGE_SOLVING
143  * - \ref SCIP_STAGE_SOLVED
144  * - \ref SCIP_STAGE_EXITSOLVE
145  * - \ref SCIP_STAGE_FREETRANS
146  */
148  SCIP* scip /**< SCIP data structure */
149  )
150 {
151  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNReoptRuns", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
152 
153  return scip->stat->nreoptruns;
154 }
155 
156 /** add given number to the number of processed nodes in current run and in all runs, including the focus node
157  *
158  * @return the number of processed nodes in current run, including the focus node
159  *
160  * @pre This method can be called if SCIP is in one of the following stages:
161  * - \ref SCIP_STAGE_PROBLEM
162  * - \ref SCIP_STAGE_TRANSFORMING
163  * - \ref SCIP_STAGE_TRANSFORMED
164  * - \ref SCIP_STAGE_INITPRESOLVE
165  * - \ref SCIP_STAGE_PRESOLVING
166  * - \ref SCIP_STAGE_EXITPRESOLVE
167  * - \ref SCIP_STAGE_PRESOLVED
168  * - \ref SCIP_STAGE_INITSOLVE
169  * - \ref SCIP_STAGE_SOLVING
170  * - \ref SCIP_STAGE_SOLVED
171  * - \ref SCIP_STAGE_EXITSOLVE
172  * - \ref SCIP_STAGE_FREETRANS
173  */
175  SCIP* scip, /**< SCIP data structure */
176  SCIP_Longint nnodes /**< number of processed nodes to add to the statistics */
177  )
178 {
179  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPaddNNodes", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
180 
181  scip->stat->nnodes += nnodes;
182  scip->stat->ntotalnodes += nnodes;
183 }
184 
185 /** gets number of processed nodes in current run, including the focus node
186  *
187  * @return the number of processed nodes in current run, including the focus node
188  *
189  * @pre This method can be called if SCIP is in one of the following stages:
190  * - \ref SCIP_STAGE_PROBLEM
191  * - \ref SCIP_STAGE_TRANSFORMING
192  * - \ref SCIP_STAGE_TRANSFORMED
193  * - \ref SCIP_STAGE_INITPRESOLVE
194  * - \ref SCIP_STAGE_PRESOLVING
195  * - \ref SCIP_STAGE_EXITPRESOLVE
196  * - \ref SCIP_STAGE_PRESOLVED
197  * - \ref SCIP_STAGE_INITSOLVE
198  * - \ref SCIP_STAGE_SOLVING
199  * - \ref SCIP_STAGE_SOLVED
200  * - \ref SCIP_STAGE_EXITSOLVE
201  * - \ref SCIP_STAGE_FREETRANS
202  */
204  SCIP* scip /**< SCIP data structure */
205  )
206 {
207  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNNodes", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
208 
209  return scip->stat->nnodes;
210 }
211 
212 /** gets total number of processed nodes in all runs, including the focus node
213  *
214  * @return the total number of processed nodes in all runs, including the focus node
215  *
216  * @pre This method can be called if SCIP is in one of the following stages:
217  * - \ref SCIP_STAGE_PROBLEM
218  * - \ref SCIP_STAGE_TRANSFORMING
219  * - \ref SCIP_STAGE_TRANSFORMED
220  * - \ref SCIP_STAGE_INITPRESOLVE
221  * - \ref SCIP_STAGE_PRESOLVING
222  * - \ref SCIP_STAGE_EXITPRESOLVE
223  * - \ref SCIP_STAGE_PRESOLVED
224  * - \ref SCIP_STAGE_INITSOLVE
225  * - \ref SCIP_STAGE_SOLVING
226  * - \ref SCIP_STAGE_SOLVED
227  * - \ref SCIP_STAGE_EXITSOLVE
228  * - \ref SCIP_STAGE_FREETRANS
229  */
231  SCIP* scip /**< SCIP data structure */
232  )
233 {
234  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNTotalNodes", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
235 
236  return scip->stat->ntotalnodes;
237 }
238 
239 /** gets number of leaf nodes processed with feasible relaxation solution
240  *
241  * @return number of leaf nodes processed with feasible relaxation solution
242  *
243  * @pre This method can be called if SCIP is in one of the following stages:
244  * - \ref SCIP_STAGE_PROBLEM
245  * - \ref SCIP_STAGE_TRANSFORMING
246  * - \ref SCIP_STAGE_TRANSFORMED
247  * - \ref SCIP_STAGE_INITPRESOLVE
248  * - \ref SCIP_STAGE_PRESOLVING
249  * - \ref SCIP_STAGE_EXITPRESOLVE
250  * - \ref SCIP_STAGE_PRESOLVED
251  * - \ref SCIP_STAGE_INITSOLVE
252  * - \ref SCIP_STAGE_SOLVING
253  * - \ref SCIP_STAGE_SOLVED
254  * - \ref SCIP_STAGE_EXITSOLVE
255  * - \ref SCIP_STAGE_FREETRANS
256  */
258  SCIP* scip /**< SCIP data structure */
259  )
260 {
261  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNFeasibleLeaves", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
262 
263  return scip->stat->nfeasleaves;
264 }
265 
266 /** gets number of infeasible leaf nodes processed
267  *
268  * @return number of infeasible leaf nodes processed
269  *
270  * @pre This method can be called if SCIP is in one of the following stages:
271  * - \ref SCIP_STAGE_PROBLEM
272  * - \ref SCIP_STAGE_TRANSFORMING
273  * - \ref SCIP_STAGE_TRANSFORMED
274  * - \ref SCIP_STAGE_INITPRESOLVE
275  * - \ref SCIP_STAGE_PRESOLVING
276  * - \ref SCIP_STAGE_EXITPRESOLVE
277  * - \ref SCIP_STAGE_PRESOLVED
278  * - \ref SCIP_STAGE_INITSOLVE
279  * - \ref SCIP_STAGE_SOLVING
280  * - \ref SCIP_STAGE_SOLVED
281  * - \ref SCIP_STAGE_EXITSOLVE
282  * - \ref SCIP_STAGE_FREETRANS
283  */
285  SCIP* scip /**< SCIP data structure */
286  )
287 {
288  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNInfeasibleLeaves", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
289 
290  return scip->stat->ninfeasleaves;
291 }
292 
293 /** gets number of processed leaf nodes that hit LP objective limit
294  *
295  * @return number of processed leaf nodes that hit LP objective limit
296  *
297  * @pre This method can be called if SCIP is in one of the following stages:
298  * - \ref SCIP_STAGE_PROBLEM
299  * - \ref SCIP_STAGE_TRANSFORMING
300  * - \ref SCIP_STAGE_TRANSFORMED
301  * - \ref SCIP_STAGE_INITPRESOLVE
302  * - \ref SCIP_STAGE_PRESOLVING
303  * - \ref SCIP_STAGE_EXITPRESOLVE
304  * - \ref SCIP_STAGE_PRESOLVED
305  * - \ref SCIP_STAGE_INITSOLVE
306  * - \ref SCIP_STAGE_SOLVING
307  * - \ref SCIP_STAGE_SOLVED
308  * - \ref SCIP_STAGE_EXITSOLVE
309  * - \ref SCIP_STAGE_FREETRANS
310  */
312  SCIP* scip /**< Scip data structure */
313  )
314 {
315  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNObjlimLeaves", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
316 
317  return scip->stat->nobjleaves;
318 }
319 
320 /** gets number of global bound changes
321  *
322  * @return number of global bound changes
323  *
324  * @pre This method can be called if SCIP is in one of the following stages:
325  * - \ref SCIP_STAGE_PROBLEM
326  * - \ref SCIP_STAGE_TRANSFORMING
327  * - \ref SCIP_STAGE_TRANSFORMED
328  * - \ref SCIP_STAGE_INITPRESOLVE
329  * - \ref SCIP_STAGE_PRESOLVING
330  * - \ref SCIP_STAGE_EXITPRESOLVE
331  * - \ref SCIP_STAGE_PRESOLVED
332  * - \ref SCIP_STAGE_INITSOLVE
333  * - \ref SCIP_STAGE_SOLVING
334  * - \ref SCIP_STAGE_SOLVED
335  * - \ref SCIP_STAGE_EXITSOLVE
336  * - \ref SCIP_STAGE_FREETRANS
337  */
339  SCIP* scip /**< Scip data structure */
340  )
341 {
342  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNRootboundChgs", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
343 
344  return scip->stat->nrootboundchgs;
345 }
346 
347 /** gets number of global bound changes applied in the current run
348  *
349  * @return number of global bound changes
350  *
351  * @pre This method can be called if SCIP is in one of the following stages:
352  * - \ref SCIP_STAGE_PROBLEM
353  * - \ref SCIP_STAGE_TRANSFORMING
354  * - \ref SCIP_STAGE_TRANSFORMED
355  * - \ref SCIP_STAGE_INITPRESOLVE
356  * - \ref SCIP_STAGE_PRESOLVING
357  * - \ref SCIP_STAGE_EXITPRESOLVE
358  * - \ref SCIP_STAGE_PRESOLVED
359  * - \ref SCIP_STAGE_INITSOLVE
360  * - \ref SCIP_STAGE_SOLVING
361  * - \ref SCIP_STAGE_SOLVED
362  * - \ref SCIP_STAGE_EXITSOLVE
363  * - \ref SCIP_STAGE_FREETRANS
364  */
366  SCIP* scip /**< Scip data structure */
367  )
368 {
369  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNRootboundChgsRun", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
370 
371  return scip->stat->nrootboundchgsrun;
372 }
373 
374 /** gets number of times a selected node was from a cut off subtree
375  *
376  * @return number of times a selected node was from a cut off subtree
377  *
378  * @pre This method can be called if SCIP is in one of the following stages:
379  * - \ref SCIP_STAGE_PROBLEM
380  * - \ref SCIP_STAGE_TRANSFORMING
381  * - \ref SCIP_STAGE_TRANSFORMED
382  * - \ref SCIP_STAGE_INITPRESOLVE
383  * - \ref SCIP_STAGE_PRESOLVING
384  * - \ref SCIP_STAGE_EXITPRESOLVE
385  * - \ref SCIP_STAGE_PRESOLVED
386  * - \ref SCIP_STAGE_INITSOLVE
387  * - \ref SCIP_STAGE_SOLVING
388  * - \ref SCIP_STAGE_SOLVED
389  * - \ref SCIP_STAGE_EXITSOLVE
390  * - \ref SCIP_STAGE_FREETRANS
391  */
393  SCIP* scip /**< SCIP data structure */
394  )
395 {
396  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNDelayedCutoffs", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
397 
398  return scip->stat->ndelayedcutoffs;
399 }
400 
401 /** gets total number of LPs solved so far
402  *
403  * @return the total number of LPs solved so far
404  *
405  * @pre This method can be called if SCIP is in one of the following stages:
406  * - \ref SCIP_STAGE_PROBLEM
407  * - \ref SCIP_STAGE_TRANSFORMING
408  * - \ref SCIP_STAGE_TRANSFORMED
409  * - \ref SCIP_STAGE_INITPRESOLVE
410  * - \ref SCIP_STAGE_PRESOLVING
411  * - \ref SCIP_STAGE_EXITPRESOLVE
412  * - \ref SCIP_STAGE_PRESOLVED
413  * - \ref SCIP_STAGE_INITSOLVE
414  * - \ref SCIP_STAGE_SOLVING
415  * - \ref SCIP_STAGE_SOLVED
416  * - \ref SCIP_STAGE_EXITSOLVE
417  * - \ref SCIP_STAGE_FREETRANS
418  */
420  SCIP* scip /**< SCIP data structure */
421  )
422 {
423  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNLPs", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
424 
425  return scip->stat->nlps;
426 }
427 
428 /** gets total number of iterations used so far in primal and dual simplex and barrier algorithm
429  *
430  * @return the total number of iterations used so far in primal and dual simplex and barrier algorithm
431  *
432  * @pre This method can be called if SCIP is in one of the following stages:
433  * - \ref SCIP_STAGE_PRESOLVING
434  * - \ref SCIP_STAGE_PRESOLVED
435  * - \ref SCIP_STAGE_SOLVING
436  * - \ref SCIP_STAGE_SOLVED
437  */
439  SCIP* scip /**< SCIP data structure */
440  )
441 {
442  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
443 
444  return scip->stat->nlpiterations;
445 }
446 
447 /** gets number of active non-zeros in the current transformed problem
448  *
449  * @return the number of active non-zeros in the current transformed problem
450  *
451  * @pre This method can be called if SCIP is in one of the following stages:
452  * - \ref SCIP_STAGE_PROBLEM
453  * - \ref SCIP_STAGE_TRANSFORMING
454  * - \ref SCIP_STAGE_TRANSFORMED
455  * - \ref SCIP_STAGE_INITPRESOLVE
456  * - \ref SCIP_STAGE_PRESOLVING
457  * - \ref SCIP_STAGE_EXITPRESOLVE
458  * - \ref SCIP_STAGE_PRESOLVED
459  * - \ref SCIP_STAGE_INITSOLVE
460  * - \ref SCIP_STAGE_SOLVING
461  * - \ref SCIP_STAGE_SOLVED
462  * - \ref SCIP_STAGE_EXITSOLVE
463  */
465  SCIP* scip /**< SCIP data structure */
466  )
467 {
468  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNNZs", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
469 
470  return scip->stat->nnz;
471 }
472 
473 /** gets total number of iterations used so far in primal and dual simplex and barrier algorithm for the root node
474  *
475  * @return the total number of iterations used so far in primal and dual simplex and barrier algorithm for the root node
476  *
477  * @pre This method can be called if SCIP is in one of the following stages:
478  * - \ref SCIP_STAGE_PRESOLVED
479  * - \ref SCIP_STAGE_SOLVING
480  * - \ref SCIP_STAGE_SOLVED
481  */
483  SCIP* scip /**< SCIP data structure */
484  )
485 {
486  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNRootLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
487 
488  return scip->stat->nrootlpiterations;
489 }
490 
491 /** gets total number of iterations used in primal and dual simplex and barrier algorithm for the first LP at the root
492  * node
493  *
494  * @return the total number of iterations used in primal and dual simplex and barrier algorithm for the first root LP
495  *
496  * @pre This method can be called if SCIP is in one of the following stages:
497  * - \ref SCIP_STAGE_PRESOLVED
498  * - \ref SCIP_STAGE_SOLVING
499  * - \ref SCIP_STAGE_SOLVED
500  */
502  SCIP* scip /**< SCIP data structure */
503  )
504 {
505  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNRootFirstLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
506 
507  return scip->stat->nrootfirstlpiterations;
508 }
509 
510 /** gets total number of primal LPs solved so far
511  *
512  * @return the total number of primal LPs solved so far
513  *
514  * @pre This method can be called if SCIP is in one of the following stages:
515  * - \ref SCIP_STAGE_PRESOLVED
516  * - \ref SCIP_STAGE_SOLVING
517  * - \ref SCIP_STAGE_SOLVED
518  */
520  SCIP* scip /**< SCIP data structure */
521  )
522 {
523  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNPrimalLPs", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
524 
525  return scip->stat->nprimallps;
526 }
527 
528 /** gets total number of iterations used so far in primal simplex
529  *
530  * @return total number of iterations used so far in primal simplex
531  *
532  * @pre This method can be called if SCIP is in one of the following stages:
533  * - \ref SCIP_STAGE_PRESOLVED
534  * - \ref SCIP_STAGE_SOLVING
535  * - \ref SCIP_STAGE_SOLVED
536  */
538  SCIP* scip /**< SCIP data structure */
539  )
540 {
541  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNPrimalLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
542 
543  return scip->stat->nprimallpiterations;
544 }
545 
546 /** gets total number of dual LPs solved so far
547  *
548  * @return the total number of dual LPs solved so far
549  *
550  * @pre This method can be called if SCIP is in one of the following stages:
551  * - \ref SCIP_STAGE_PRESOLVED
552  * - \ref SCIP_STAGE_SOLVING
553  * - \ref SCIP_STAGE_SOLVED
554  */
556  SCIP* scip /**< SCIP data structure */
557  )
558 {
559  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNDualLPs", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
560 
561  return scip->stat->nduallps;
562 }
563 
564 /** gets total number of iterations used so far in dual simplex
565  *
566  * @return the total number of iterations used so far in dual simplex
567  *
568  * @pre This method can be called if SCIP is in one of the following stages:
569  * - \ref SCIP_STAGE_PRESOLVED
570  * - \ref SCIP_STAGE_SOLVING
571  * - \ref SCIP_STAGE_SOLVED
572  */
574  SCIP* scip /**< SCIP data structure */
575  )
576 {
577  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNDualLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
578 
579  return scip->stat->nduallpiterations;
580 }
581 
582 /** gets total number of barrier LPs solved so far
583  *
584  * @return the total number of barrier LPs solved so far
585  *
586  * @pre This method can be called if SCIP is in one of the following stages:
587  * - \ref SCIP_STAGE_PRESOLVED
588  * - \ref SCIP_STAGE_SOLVING
589  * - \ref SCIP_STAGE_SOLVED
590  */
592  SCIP* scip /**< SCIP data structure */
593  )
594 {
595  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNBarrierLPs", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
596 
597  return scip->stat->nbarrierlps;
598 }
599 
600 /** gets total number of iterations used so far in barrier algorithm
601  *
602  * @return the total number of iterations used so far in barrier algorithm
603  *
604  * @pre This method can be called if SCIP is in one of the following stages:
605  * - \ref SCIP_STAGE_PRESOLVED
606  * - \ref SCIP_STAGE_SOLVING
607  * - \ref SCIP_STAGE_SOLVED
608  */
610  SCIP* scip /**< SCIP data structure */
611  )
612 {
613  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNBarrierLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
614 
615  return scip->stat->nbarrierlpiterations;
616 }
617 
618 /** gets total number of LPs solved so far that were resolved from an advanced start basis
619  *
620  * @return the total number of LPs solved so far that were resolved from an advanced start basis
621  *
622  * @pre This method can be called if SCIP is in one of the following stages:
623  * - \ref SCIP_STAGE_PRESOLVED
624  * - \ref SCIP_STAGE_SOLVING
625  * - \ref SCIP_STAGE_SOLVED
626  */
628  SCIP* scip /**< SCIP data structure */
629  )
630 {
631  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNResolveLPs", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
632 
633  return scip->stat->nprimalresolvelps + scip->stat->ndualresolvelps;
634 }
635 
636 /** gets total number of simplex iterations used so far in primal and dual simplex calls where an advanced start basis
637  * was available
638  *
639  * @return the total number of simplex iterations used so far in primal and dual simplex calls where an advanced start
640  * basis was available
641  *
642  * @pre This method can be called if SCIP is in one of the following stages:
643  * - \ref SCIP_STAGE_PRESOLVED
644  * - \ref SCIP_STAGE_SOLVING
645  * - \ref SCIP_STAGE_SOLVED
646  */
648  SCIP* scip /**< SCIP data structure */
649  )
650 {
651  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNResolveLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
652 
654 }
655 
656 /** gets total number of primal LPs solved so far that were resolved from an advanced start basis
657  *
658  * @return the total number of primal LPs solved so far that were resolved from an advanced start basis
659  *
660  * @pre This method can be called if SCIP is in one of the following stages:
661  * - \ref SCIP_STAGE_PRESOLVED
662  * - \ref SCIP_STAGE_SOLVING
663  * - \ref SCIP_STAGE_SOLVED
664  */
666  SCIP* scip /**< SCIP data structure */
667  )
668 {
669  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNPrimalResolveLPs", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
670 
671  return scip->stat->nprimalresolvelps;
672 }
673 
674 /** gets total number of simplex iterations used so far in primal simplex calls where an advanced start basis
675  * was available
676  *
677  * @return the total number of simplex iterations used so far in primal simplex calls where an advanced start
678  * basis was available
679  *
680  * @pre This method can be called if SCIP is in one of the following stages:
681  * - \ref SCIP_STAGE_PRESOLVED
682  * - \ref SCIP_STAGE_SOLVING
683  * - \ref SCIP_STAGE_SOLVED
684  */
686  SCIP* scip /**< SCIP data structure */
687  )
688 {
689  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNPrimalResolveLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
690 
691  return scip->stat->nprimalresolvelpiterations;
692 }
693 
694 /** gets total number of dual LPs solved so far that were resolved from an advanced start basis
695  *
696  * @return the total number of dual LPs solved so far that were resolved from an advanced start basis
697  *
698  * @pre This method can be called if SCIP is in one of the following stages:
699  * - \ref SCIP_STAGE_PRESOLVED
700  * - \ref SCIP_STAGE_SOLVING
701  * - \ref SCIP_STAGE_SOLVED
702  */
704  SCIP* scip /**< SCIP data structure */
705  )
706 {
707  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNDualResolveLPs", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
708 
709  return scip->stat->ndualresolvelps;
710 }
711 
712 /** gets total number of simplex iterations used so far in dual simplex calls where an advanced start basis
713  * was available
714  *
715  * @return the total number of simplex iterations used so far in dual simplex calls where an advanced start
716  * basis was available
717  *
718  * @pre This method can be called if SCIP is in one of the following stages:
719  * - \ref SCIP_STAGE_PRESOLVED
720  * - \ref SCIP_STAGE_SOLVING
721  * - \ref SCIP_STAGE_SOLVED
722  */
724  SCIP* scip /**< SCIP data structure */
725  )
726 {
727  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNDualResolveLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
728 
729  return scip->stat->ndualresolvelpiterations;
730 }
731 
732 /** gets total number of LPs solved so far for node relaxations
733  *
734  * @return the total number of LPs solved so far for node relaxations
735  *
736  * @pre This method can be called if SCIP is in one of the following stages:
737  * - \ref SCIP_STAGE_PRESOLVED
738  * - \ref SCIP_STAGE_SOLVING
739  * - \ref SCIP_STAGE_SOLVED
740  */
742  SCIP* scip /**< SCIP data structure */
743  )
744 {
745  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNNodeLPs", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
746 
747  return scip->stat->nnodelps;
748 }
749 
750 /** gets total number of LPs solved in 0 iterations for node relaxations
751  *
752  * @return the total number of LPs solved with 0 iteratins for node relaxations
753  *
754  * @pre This method can be called if SCIP is in one of the following stages:
755  * - \ref SCIP_STAGE_PRESOLVED
756  * - \ref SCIP_STAGE_SOLVING
757  * - \ref SCIP_STAGE_SOLVED
758  */
760  SCIP* scip /**< SCIP data structure */
761  )
762 {
763  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNNodeZeroIterationLPs", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
764 
765  return scip->stat->nnodezeroitlps;
766 }
767 
768 /** gets total number of simplex iterations used so far for node relaxations
769  *
770  * @return the total number of simplex iterations used so far for node relaxations
771  *
772  * @pre This method can be called if SCIP is in one of the following stages:
773  * - \ref SCIP_STAGE_PRESOLVED
774  * - \ref SCIP_STAGE_SOLVING
775  * - \ref SCIP_STAGE_SOLVED
776  */
778  SCIP* scip /**< SCIP data structure */
779  )
780 {
781  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNNodeLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
782 
783  return scip->stat->nnodelpiterations;
784 }
785 
786 /** gets total number of LPs solved so far for initial LP in node relaxations
787  *
788  * @return the total number of LPs solved so far for initial LP in node relaxations
789  *
790  * @pre This method can be called if SCIP is in one of the following stages:
791  * - \ref SCIP_STAGE_PRESOLVED
792  * - \ref SCIP_STAGE_SOLVING
793  * - \ref SCIP_STAGE_SOLVED
794  */
796  SCIP* scip /**< SCIP data structure */
797  )
798 {
799  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNNodeInitLPs", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
800 
801  return scip->stat->ninitlps;
802 }
803 
804 /** gets total number of simplex iterations used so far for initial LP in node relaxations
805  *
806  * @return the total number of simplex iterations used so far for initial LP in node relaxations
807  *
808  * @pre This method can be called if SCIP is in one of the following stages:
809  * - \ref SCIP_STAGE_PRESOLVED
810  * - \ref SCIP_STAGE_SOLVING
811  * - \ref SCIP_STAGE_SOLVED
812  */
814  SCIP* scip /**< SCIP data structure */
815  )
816 {
817  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNNodeInitLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
818 
819  return scip->stat->ninitlpiterations;
820 }
821 
822 /** gets total number of LPs solved so far during diving and probing
823  *
824  * @return total number of LPs solved so far during diving and probing
825  *
826  * @pre This method can be called if SCIP is in one of the following stages:
827  * - \ref SCIP_STAGE_PRESOLVED
828  * - \ref SCIP_STAGE_SOLVING
829  * - \ref SCIP_STAGE_SOLVED
830  */
832  SCIP* scip /**< SCIP data structure */
833  )
834 {
835  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNDivingLPs", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
836 
837  return scip->stat->ndivinglps;
838 }
839 
840 /** gets total number of simplex iterations used so far during diving and probing
841  *
842  * @return the total number of simplex iterations used so far during diving and probing
843  *
844  * @pre This method can be called if SCIP is in one of the following stages:
845  * - \ref SCIP_STAGE_PRESOLVED
846  * - \ref SCIP_STAGE_SOLVING
847  * - \ref SCIP_STAGE_SOLVED
848  */
850  SCIP* scip /**< SCIP data structure */
851  )
852 {
853  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNDivingLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
854 
855  return scip->stat->ndivinglpiterations;
856 }
857 
858 /** gets total number of times, strong branching was called (each call represents solving two LPs)
859  *
860  * @return the total number of times, strong branching was called (each call represents solving two LPs)
861  *
862  * @pre This method can be called if SCIP is in one of the following stages:
863  * - \ref SCIP_STAGE_PRESOLVED
864  * - \ref SCIP_STAGE_SOLVING
865  * - \ref SCIP_STAGE_SOLVED
866  */
868  SCIP* scip /**< SCIP data structure */
869  )
870 {
871  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNStrongbranchs", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
872 
873  return scip->stat->nstrongbranchs;
874 }
875 
876 /** gets total number of simplex iterations used so far in strong branching
877  *
878  * @return the total number of simplex iterations used so far in strong branching
879  *
880  * @pre This method can be called if SCIP is in one of the following stages:
881  * - \ref SCIP_STAGE_PRESOLVED
882  * - \ref SCIP_STAGE_SOLVING
883  * - \ref SCIP_STAGE_SOLVED
884  */
886  SCIP* scip /**< SCIP data structure */
887  )
888 {
889  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNStrongbranchLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
890 
891  return scip->stat->nsblpiterations;
892 }
893 
894 /** gets total number of times, strong branching was called at the root node (each call represents solving two LPs)
895  *
896  * @return the total number of times, strong branching was called at the root node (each call represents solving two LPs)
897  *
898  * @pre This method can be called if SCIP is in one of the following stages:
899  * - \ref SCIP_STAGE_PRESOLVED
900  * - \ref SCIP_STAGE_SOLVING
901  * - \ref SCIP_STAGE_SOLVED
902  */
904  SCIP* scip /**< SCIP data structure */
905  )
906 {
907  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNRootStrongbranchs", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
908 
909  return scip->stat->nrootstrongbranchs;
910 }
911 
912 /** gets total number of simplex iterations used so far in strong branching at the root node
913  *
914  * @return the total number of simplex iterations used so far in strong branching at the root node
915  *
916  * @pre This method can be called if SCIP is in one of the following stages:
917  * - \ref SCIP_STAGE_PRESOLVED
918  * - \ref SCIP_STAGE_SOLVING
919  * - \ref SCIP_STAGE_SOLVED
920  */
922  SCIP* scip /**< SCIP data structure */
923  )
924 {
925  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNRootStrongbranchLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
926 
927  return scip->stat->nrootsblpiterations;
928 }
929 
930 /** gets number of pricing rounds performed so far at the current node
931  *
932  * @return the number of pricing rounds performed so far at the current node
933  *
934  * @pre This method can be called if SCIP is in one of the following stages:
935  * - \ref SCIP_STAGE_SOLVING
936  */
938  SCIP* scip /**< SCIP data structure */
939  )
940 {
941  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNPriceRounds", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
942 
943  return scip->stat->npricerounds;
944 }
945 
946 /** get current number of variables in the pricing store
947  *
948  * @return the current number of variables in the pricing store
949  *
950  * @pre This method can be called if SCIP is in one of the following stages:
951  * - \ref SCIP_STAGE_PRESOLVED
952  * - \ref SCIP_STAGE_SOLVING
953  * - \ref SCIP_STAGE_SOLVED
954  */
956  SCIP* scip /**< SCIP data structure */
957  )
958 {
959  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNPricevars", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
960 
961  return scip->pricestore == NULL ? 0 : SCIPpricestoreGetNVars(scip->pricestore);
962 }
963 
964 /** get total number of pricing variables found so far
965  *
966  * @return the total number of pricing variables found so far
967  *
968  * @pre This method can be called if SCIP is in one of the following stages:
969  * - \ref SCIP_STAGE_PRESOLVED
970  * - \ref SCIP_STAGE_SOLVING
971  * - \ref SCIP_STAGE_SOLVED
972  */
974  SCIP* scip /**< SCIP data structure */
975  )
976 {
977  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNPricevarsFound", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
978 
979  return scip->pricestore == NULL ? 0 : SCIPpricestoreGetNVarsFound(scip->pricestore);
980 }
981 
982 /** get total number of pricing variables applied to the LPs
983  *
984  * @return the total number of pricing variables applied to the LPs
985  *
986  * @pre This method can be called if SCIP is in one of the following stages:
987  * - \ref SCIP_STAGE_PRESOLVED
988  * - \ref SCIP_STAGE_SOLVING
989  * - \ref SCIP_STAGE_SOLVED
990  */
992  SCIP* scip /**< SCIP data structure */
993  )
994 {
995  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNPricevarsApplied", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
996 
997  return scip->pricestore == NULL ? 0 : SCIPpricestoreGetNVarsApplied(scip->pricestore);
998 }
999 
1000 /** gets number of separation rounds performed so far at the current node
1001  *
1002  * @return the number of separation rounds performed so far at the current node
1003  *
1004  * @pre This method can be called if SCIP is in one of the following stages:
1005  * - \ref SCIP_STAGE_SOLVING
1006  */
1008  SCIP* scip /**< SCIP data structure */
1009  )
1010 {
1011  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNSepaRounds", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1012 
1013  return scip->stat->nseparounds;
1014 }
1015 
1016 /** get total number of cuts added to the sepastore so far; this includes global cuts from the cut pool as often as they are separated
1017  *
1018  * @return the total number of cuts added to the sepastore so far
1019  *
1020  * @pre This method can be called if SCIP is in one of the following stages:
1021  * - \ref SCIP_STAGE_PRESOLVED
1022  * - \ref SCIP_STAGE_SOLVING
1023  * - \ref SCIP_STAGE_SOLVED
1024  */
1026  SCIP* scip /**< SCIP data structure */
1027  )
1028 {
1029  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNCutsFound", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1030 
1031  return scip->sepastore == NULL ? 0 : SCIPsepastoreGetNCutsAdded(scip->sepastore);
1032 }
1033 
1034 /** get number of cuts found so far in current separation round
1035  *
1036  * @return the number of cuts found so far in current separation round
1037  *
1038  * @pre This method can be called if SCIP is in one of the following stages:
1039  * - \ref SCIP_STAGE_PRESOLVED
1040  * - \ref SCIP_STAGE_SOLVING
1041  * - \ref SCIP_STAGE_SOLVED
1042  */
1044  SCIP* scip /**< SCIP data structure */
1045  )
1046 {
1047  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNCutsFoundRound", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1048 
1049  return scip->sepastore == NULL ? 0 : SCIPsepastoreGetNCutsFoundRound(scip->sepastore);
1050 }
1051 
1052 /** get total number of cuts applied to the LPs
1053  *
1054  * @return the total number of cuts applied to the LPs
1055  *
1056  * @pre This method can be called if SCIP is in one of the following stages:
1057  * - \ref SCIP_STAGE_PRESOLVED
1058  * - \ref SCIP_STAGE_SOLVING
1059  * - \ref SCIP_STAGE_SOLVED
1060  */
1062  SCIP* scip /**< SCIP data structure */
1063  )
1064 {
1065  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNCutsApplied", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1066 
1067  return scip->sepastore == NULL ? 0 : SCIPsepastoreGetNCutsApplied(scip->sepastore);
1068 }
1069 
1070 /** get total number of constraints found in conflict analysis (conflict, reconvergence constraints, and dual proofs)
1071  *
1072  * @return the total number of constraints found in conflict analysis (conflict, reconvergence constraints, and dual proofs)
1073  *
1074  * @pre This method can be called if SCIP is in one of the following stages:
1075  * - \ref SCIP_STAGE_TRANSFORMED
1076  * - \ref SCIP_STAGE_INITPRESOLVE
1077  * - \ref SCIP_STAGE_PRESOLVING
1078  * - \ref SCIP_STAGE_EXITPRESOLVE
1079  * - \ref SCIP_STAGE_PRESOLVED
1080  * - \ref SCIP_STAGE_INITSOLVE
1081  * - \ref SCIP_STAGE_SOLVING
1082  * - \ref SCIP_STAGE_SOLVED
1083  * - \ref SCIP_STAGE_EXITSOLVE
1084  */
1086  SCIP* scip /**< SCIP data structure */
1087  )
1088 {
1089  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNConflictConssFound", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1090 
1091  return scip->conflict == NULL ? 0 : (SCIPconflictGetNPropConflictConss(scip->conflict)
1103 }
1104 
1105 /** get number of conflict constraints found so far at the current node
1106  *
1107  * @return the number of conflict constraints found so far at the current node
1108  *
1109  * @pre This method can be called if SCIP is in one of the following stages:
1110  * - \ref SCIP_STAGE_TRANSFORMED
1111  * - \ref SCIP_STAGE_INITPRESOLVE
1112  * - \ref SCIP_STAGE_PRESOLVING
1113  * - \ref SCIP_STAGE_EXITPRESOLVE
1114  * - \ref SCIP_STAGE_PRESOLVED
1115  * - \ref SCIP_STAGE_INITSOLVE
1116  * - \ref SCIP_STAGE_SOLVING
1117  * - \ref SCIP_STAGE_SOLVED
1118  * - \ref SCIP_STAGE_EXITSOLVE
1119  */
1121  SCIP* scip /**< SCIP data structure */
1122  )
1123 {
1124  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNConflictConssFoundNode", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1125 
1126  return scip->conflict == NULL ? 0 : SCIPconflictGetNConflicts(scip->conflict);
1127 }
1128 
1129 /** get total number of conflict constraints added to the problem
1130  *
1131  * @return the total number of conflict constraints added to the problem
1132  *
1133  * @pre This method can be called if SCIP is in one of the following stages:
1134  * - \ref SCIP_STAGE_TRANSFORMED
1135  * - \ref SCIP_STAGE_INITPRESOLVE
1136  * - \ref SCIP_STAGE_PRESOLVING
1137  * - \ref SCIP_STAGE_EXITPRESOLVE
1138  * - \ref SCIP_STAGE_PRESOLVED
1139  * - \ref SCIP_STAGE_INITSOLVE
1140  * - \ref SCIP_STAGE_SOLVING
1141  * - \ref SCIP_STAGE_SOLVED
1142  * - \ref SCIP_STAGE_EXITSOLVE
1143  */
1145  SCIP* scip /**< SCIP data structure */
1146  )
1147 {
1148  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNConflictConssApplied", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1149 
1150  return scip->conflict == NULL ? 0 : SCIPconflictGetNAppliedConss(scip->conflict);
1151 }
1152 
1153 /** get total number of dual proof constraints added to the problem
1154  *
1155  * @return the total number of dual proof constraints added to the problem
1156  *
1157  * @pre This method can be called if SCIP is in one of the following stages:
1158  * - \ref SCIP_STAGE_TRANSFORMED
1159  * - \ref SCIP_STAGE_INITPRESOLVE
1160  * - \ref SCIP_STAGE_PRESOLVING
1161  * - \ref SCIP_STAGE_EXITPRESOLVE
1162  * - \ref SCIP_STAGE_PRESOLVED
1163  * - \ref SCIP_STAGE_INITSOLVE
1164  * - \ref SCIP_STAGE_SOLVING
1165  * - \ref SCIP_STAGE_SOLVED
1166  * - \ref SCIP_STAGE_EXITSOLVE
1167  */
1169  SCIP* scip /**< SCIP data structure */
1170  )
1171 {
1172  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNConflictDualproofsApplied", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1173 
1174  return scip->conflict == NULL ? 0 : (SCIPconflictGetNDualproofsInfSuccess(scip->conflict) +
1176 }
1177 
1178 /** gets maximal depth of all processed nodes in current branch and bound run (excluding probing nodes)
1179  *
1180  * @return the maximal depth of all processed nodes in current branch and bound run (excluding probing nodes)
1181  *
1182  * @pre This method can be called if SCIP is in one of the following stages:
1183  * - \ref SCIP_STAGE_TRANSFORMED
1184  * - \ref SCIP_STAGE_INITPRESOLVE
1185  * - \ref SCIP_STAGE_PRESOLVING
1186  * - \ref SCIP_STAGE_EXITPRESOLVE
1187  * - \ref SCIP_STAGE_PRESOLVED
1188  * - \ref SCIP_STAGE_INITSOLVE
1189  * - \ref SCIP_STAGE_SOLVING
1190  * - \ref SCIP_STAGE_SOLVED
1191  * - \ref SCIP_STAGE_EXITSOLVE
1192  */
1194  SCIP* scip /**< SCIP data structure */
1195  )
1196 {
1197  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetMaxDepth", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1198 
1199  return scip->stat->maxdepth;
1200 }
1201 
1202 /** gets maximal depth of all processed nodes over all branch and bound runs
1203  *
1204  * @return the maximal depth of all processed nodes over all branch and bound runs
1205  *
1206  * @pre This method can be called if SCIP is in one of the following stages:
1207  * - \ref SCIP_STAGE_TRANSFORMED
1208  * - \ref SCIP_STAGE_INITPRESOLVE
1209  * - \ref SCIP_STAGE_PRESOLVING
1210  * - \ref SCIP_STAGE_EXITPRESOLVE
1211  * - \ref SCIP_STAGE_PRESOLVED
1212  * - \ref SCIP_STAGE_INITSOLVE
1213  * - \ref SCIP_STAGE_SOLVING
1214  * - \ref SCIP_STAGE_SOLVED
1215  * - \ref SCIP_STAGE_EXITSOLVE
1216  */
1218  SCIP* scip /**< SCIP data structure */
1219  )
1220 {
1221  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetMaxTotalDepth", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1222 
1223  return scip->stat->maxtotaldepth;
1224 }
1225 
1226 /** gets total number of backtracks, i.e. number of times, the new node was selected from the leaves queue
1227  *
1228  * @return the total number of backtracks, i.e. number of times, the new node was selected from the leaves queue
1229  *
1230  * @pre This method can be called if SCIP is in one of the following stages:
1231  * - \ref SCIP_STAGE_TRANSFORMED
1232  * - \ref SCIP_STAGE_INITPRESOLVE
1233  * - \ref SCIP_STAGE_PRESOLVING
1234  * - \ref SCIP_STAGE_EXITPRESOLVE
1235  * - \ref SCIP_STAGE_PRESOLVED
1236  * - \ref SCIP_STAGE_INITSOLVE
1237  * - \ref SCIP_STAGE_SOLVING
1238  * - \ref SCIP_STAGE_SOLVED
1239  * - \ref SCIP_STAGE_EXITSOLVE
1240  */
1242  SCIP* scip /**< SCIP data structure */
1243  )
1244 {
1245  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNBacktracks", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1246 
1247  return scip->stat->nbacktracks;
1248 }
1249 
1250 /** gets total number of active constraints at the current node
1251  *
1252  * @return the total number of active constraints at the current node
1253  *
1254  * @pre This method can be called if SCIP is in one of the following stages:
1255  * - \ref SCIP_STAGE_INITPRESOLVE
1256  * - \ref SCIP_STAGE_PRESOLVING
1257  * - \ref SCIP_STAGE_EXITPRESOLVE
1258  * - \ref SCIP_STAGE_PRESOLVED
1259  * - \ref SCIP_STAGE_SOLVING
1260  */
1262  SCIP* scip /**< SCIP data structure */
1263  )
1264 {
1265  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNActiveConss", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1266 
1267  return scip->stat->nactiveconss;
1268 }
1269 
1270 /** gets total number of enabled constraints at the current node
1271  *
1272  * @return the total number of enabled constraints at the current node
1273  *
1274  * @pre This method can be called if SCIP is in one of the following stages:
1275  * - \ref SCIP_STAGE_PRESOLVED
1276  * - \ref SCIP_STAGE_SOLVING
1277  */
1279  SCIP* scip /**< SCIP data structure */
1280  )
1281 {
1282  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNEnabledConss", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1283 
1284  return scip->stat->nenabledconss;
1285 }
1286 
1287 /** gets average dual bound of all unprocessed nodes for original problem
1288  *
1289  * @return the average dual bound of all unprocessed nodes for original problem
1290  *
1291  * @pre This method can be called if SCIP is in one of the following stages:
1292  * - \ref SCIP_STAGE_PRESOLVED
1293  * - \ref SCIP_STAGE_SOLVING
1294  * - \ref SCIP_STAGE_SOLVED
1295  */
1297  SCIP* scip /**< SCIP data structure */
1298  )
1299 {
1300  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgDualbound", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1301 
1302  return SCIPprobExternObjval(scip->transprob, scip->origprob, scip->set,
1304 }
1305 
1306 /** gets average lower (dual) bound of all unprocessed nodes in transformed problem
1307  *
1308  * @return the average lower (dual) bound of all unprocessed nodes in transformed problem
1309  *
1310  * @pre This method can be called if SCIP is in one of the following stages:
1311  * - \ref SCIP_STAGE_PRESOLVED
1312  * - \ref SCIP_STAGE_SOLVING
1313  * - \ref SCIP_STAGE_SOLVED
1314  */
1316  SCIP* scip /**< SCIP data structure */
1317  )
1318 {
1319  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgLowerbound", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1320 
1321  return SCIPtreeGetAvgLowerbound(scip->tree, scip->primal->cutoffbound);
1322 }
1323 
1324 /** gets global dual bound
1325  *
1326  * @return the global dual bound
1327  *
1328  * @pre This method can be called if SCIP is in one of the following stages:
1329  * - \ref SCIP_STAGE_TRANSFORMED
1330  * - \ref SCIP_STAGE_INITPRESOLVE
1331  * - \ref SCIP_STAGE_PRESOLVING
1332  * - \ref SCIP_STAGE_EXITPRESOLVE
1333  * - \ref SCIP_STAGE_PRESOLVED
1334  * - \ref SCIP_STAGE_INITSOLVE
1335  * - \ref SCIP_STAGE_SOLVING
1336  * - \ref SCIP_STAGE_SOLVED
1337  * - \ref SCIP_STAGE_EXITSOLVE
1338  */
1340  SCIP* scip /**< SCIP data structure */
1341  )
1342 {
1343  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetDualbound", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1344 
1345  /* in case we are in presolving we use the stored dual bound if it exits */
1346  if( scip->set->stage <= SCIP_STAGE_INITSOLVE && scip->transprob->dualbound < SCIP_INVALID )
1347  return scip->transprob->dualbound;
1348 
1349  return SCIPprobExternObjval(scip->transprob, scip->origprob, scip->set, SCIPgetLowerbound(scip));
1350 }
1351 
1352 /** gets global lower (dual) bound in transformed problem
1353  *
1354  * @return the global lower (dual) bound in transformed problem
1355  *
1356  * @pre This method can be called if SCIP is in one of the following stages:
1357  * - \ref SCIP_STAGE_TRANSFORMED
1358  * - \ref SCIP_STAGE_INITPRESOLVE
1359  * - \ref SCIP_STAGE_PRESOLVING
1360  * - \ref SCIP_STAGE_EXITPRESOLVE
1361  * - \ref SCIP_STAGE_PRESOLVED
1362  * - \ref SCIP_STAGE_INITSOLVE
1363  * - \ref SCIP_STAGE_SOLVING
1364  * - \ref SCIP_STAGE_SOLVED
1365  */
1367  SCIP* scip /**< SCIP data structure */
1368  )
1369 {
1370  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetLowerbound", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1371 
1372  if( scip->set->stage <= SCIP_STAGE_INITSOLVE )
1373  return -SCIPinfinity(scip);
1375  {
1376  /* in case we could not prove whether the problem is unbounded or infeasible, we want to terminate with lower
1377  * bound = -inf instead of lower bound = upper bound = +inf also in case we prove that the problem is unbounded,
1378  * it seems to make sense to return with lower bound = -inf, since -infinity is the only valid lower bound
1379  */
1380  return -SCIPinfinity(scip);
1381  }
1382  else if( SCIPgetStatus(scip) == SCIP_STATUS_INFEASIBLE )
1383  {
1384  /* SCIPtreeGetLowerbound() should return +inf in the case of infeasibility, but when infeasibility is detected
1385  * during presolving this does not seem to be the case; hence, we treat this case explicitly
1386  */
1387  return SCIPinfinity(scip);
1388  }
1389  else
1390  {
1391  SCIP_Real treelowerbound;
1392 
1393  /* it may happen that the remaining tree is empty or all open nodes have a lower bound above the cutoff bound, but
1394  * have not yet been cut off, e.g., when the user calls SCIPgetDualbound() in some event handler; in this case,
1395  * the global lower bound is given by the upper bound value
1396  */
1397  treelowerbound = SCIPtreeGetLowerbound(scip->tree, scip->set);
1398 
1399  if( treelowerbound < scip->primal->upperbound)
1400  return treelowerbound;
1401  else
1402  return scip->primal->upperbound;
1403  }
1404 }
1405 
1406 /** gets dual bound of the root node for the original problem
1407  *
1408  * @return the dual bound of the root node for the original problem
1409  *
1410  * @pre This method can be called if SCIP is in one of the following stages:
1411  * - \ref SCIP_STAGE_PRESOLVING
1412  * - \ref SCIP_STAGE_EXITPRESOLVE
1413  * - \ref SCIP_STAGE_PRESOLVED
1414  * - \ref SCIP_STAGE_INITSOLVE
1415  * - \ref SCIP_STAGE_SOLVING
1416  * - \ref SCIP_STAGE_SOLVED
1417  */
1419  SCIP* scip /**< SCIP data structure */
1420  )
1421 {
1422  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetDualboundRoot", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1423 
1424  if( SCIPsetIsInfinity(scip->set, scip->stat->rootlowerbound) )
1425  return SCIPgetPrimalbound(scip);
1426  else
1427  return SCIPprobExternObjval(scip->transprob, scip->origprob, scip->set, scip->stat->rootlowerbound);
1428 }
1429 
1430 /** gets lower (dual) bound in transformed problem of the root node
1431  *
1432  * @return the lower (dual) bound in transformed problem of the root node
1433  *
1434  * @pre This method can be called if SCIP is in one of the following stages:
1435  * - \ref SCIP_STAGE_PRESOLVING
1436  * - \ref SCIP_STAGE_EXITPRESOLVE
1437  * - \ref SCIP_STAGE_PRESOLVED
1438  * - \ref SCIP_STAGE_INITSOLVE
1439  * - \ref SCIP_STAGE_SOLVING
1440  * - \ref SCIP_STAGE_SOLVED
1441  */
1443  SCIP* scip /**< SCIP data structure */
1444  )
1445 {
1446  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetLowerboundRoot", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1447 
1448  if( SCIPsetIsInfinity(scip->set, scip->stat->rootlowerbound) )
1449  return SCIPgetUpperbound(scip);
1450  else
1451  return scip->stat->rootlowerbound;
1452 }
1453 
1454 /** gets dual bound for the original problem obtained by the first LP solve at the root node
1455  *
1456  * @return the dual bound for the original problem of the first LP solve at the root node
1457  *
1458  * @pre This method can be called if SCIP is in one of the following stages:
1459  * - \ref SCIP_STAGE_PRESOLVING
1460  * - \ref SCIP_STAGE_EXITPRESOLVE
1461  * - \ref SCIP_STAGE_PRESOLVED
1462  * - \ref SCIP_STAGE_INITSOLVE
1463  * - \ref SCIP_STAGE_SOLVING
1464  * - \ref SCIP_STAGE_SOLVED
1465  */
1467  SCIP* scip /**< SCIP data structure */
1468  )
1469 {
1470  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetFirstLPDualboundRoot", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1471 
1472  return scip->stat->firstlpdualbound;
1473 }
1474 
1475 /** gets lower (dual) bound in transformed problem obtained by the first LP solve at the root node
1476  *
1477  * @return the lower (dual) bound in transformed problem obtained by first LP solve at the root node
1478  *
1479  * @pre This method can be called if SCIP is in one of the following stages:
1480  * - \ref SCIP_STAGE_PRESOLVING
1481  * - \ref SCIP_STAGE_EXITPRESOLVE
1482  * - \ref SCIP_STAGE_PRESOLVED
1483  * - \ref SCIP_STAGE_INITSOLVE
1484  * - \ref SCIP_STAGE_SOLVING
1485  * - \ref SCIP_STAGE_SOLVED
1486  */
1488  SCIP* scip /**< SCIP data structure */
1489  )
1490 {
1491  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetFirstLPLowerboundRoot", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1492 
1493  if( scip->stat->firstlpdualbound == SCIP_INVALID ) /*lint !e777*/
1494  return -SCIPinfinity(scip);
1495  else
1496  return SCIPprobInternObjval(scip->transprob, scip->origprob, scip->set, scip->stat->firstlpdualbound);
1497 }
1498 
1499 /** the primal bound of the very first solution */
1501  SCIP* scip /**< SCIP data structure */
1502  )
1503 {
1504  return scip->stat->firstprimalbound;
1505 }
1506 
1507 /** gets global primal bound (objective value of best solution or user objective limit) for the original problem
1508  *
1509  * @return the global primal bound (objective value of best solution or user objective limit) for the original problem
1510  *
1511  * @pre This method can be called if SCIP is in one of the following stages:
1512  * - \ref SCIP_STAGE_TRANSFORMED
1513  * - \ref SCIP_STAGE_INITPRESOLVE
1514  * - \ref SCIP_STAGE_PRESOLVING
1515  * - \ref SCIP_STAGE_EXITPRESOLVE
1516  * - \ref SCIP_STAGE_PRESOLVED
1517  * - \ref SCIP_STAGE_INITSOLVE
1518  * - \ref SCIP_STAGE_SOLVING
1519  * - \ref SCIP_STAGE_SOLVED
1520  * - \ref SCIP_STAGE_EXITSOLVE
1521  */
1523  SCIP* scip /**< SCIP data structure */
1524  )
1525 {
1526  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetPrimalbound", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1527 
1528  return SCIPprobExternObjval(scip->transprob, scip->origprob, scip->set, SCIPgetUpperbound(scip));
1529 }
1530 
1531 /** gets global upper (primal) bound in transformed problem (objective value of best solution or user objective limit)
1532  *
1533  * @return the global upper (primal) bound in transformed problem (objective value of best solution or user objective limit)
1534  *
1535  * @pre This method can be called if SCIP is in one of the following stages:
1536  * - \ref SCIP_STAGE_TRANSFORMED
1537  * - \ref SCIP_STAGE_INITPRESOLVE
1538  * - \ref SCIP_STAGE_PRESOLVING
1539  * - \ref SCIP_STAGE_EXITPRESOLVE
1540  * - \ref SCIP_STAGE_PRESOLVED
1541  * - \ref SCIP_STAGE_INITSOLVE
1542  * - \ref SCIP_STAGE_SOLVING
1543  * - \ref SCIP_STAGE_SOLVED
1544  * - \ref SCIP_STAGE_EXITSOLVE
1545  */
1547  SCIP* scip /**< SCIP data structure */
1548  )
1549 {
1550  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetUpperbound", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1551 
1552  if( SCIPgetStatus(scip) == SCIP_STATUS_UNBOUNDED )
1553  return -SCIPinfinity(scip);
1554  else
1555  return scip->primal->upperbound;
1556 }
1557 
1558 /** gets global cutoff bound in transformed problem: a sub problem with lower bound larger than the cutoff
1559  * cannot contain a better feasible solution; usually, this bound is equal to the upper bound, but if the
1560  * objective value is always integral, the cutoff bound is (nearly) one less than the upper bound;
1561  * additionally, due to objective function domain propagation, the cutoff bound can be further reduced
1562  *
1563  * @return global cutoff bound in transformed problem
1564  *
1565  * @pre This method can be called if SCIP is in one of the following stages:
1566  * - \ref SCIP_STAGE_TRANSFORMED
1567  * - \ref SCIP_STAGE_INITPRESOLVE
1568  * - \ref SCIP_STAGE_PRESOLVING
1569  * - \ref SCIP_STAGE_EXITPRESOLVE
1570  * - \ref SCIP_STAGE_PRESOLVED
1571  * - \ref SCIP_STAGE_INITSOLVE
1572  * - \ref SCIP_STAGE_SOLVING
1573  * - \ref SCIP_STAGE_SOLVED
1574  * - \ref SCIP_STAGE_EXITSOLVE
1575  */
1577  SCIP* scip /**< SCIP data structure */
1578  )
1579 {
1580  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetCutoffbound", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1581 
1582  return scip->primal->cutoffbound;
1583 }
1584 
1585 /** updates the cutoff bound
1586  *
1587  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1588  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1589  *
1590  * @note using this method in the solving stage can lead to an erroneous SCIP solving status; in particular,
1591  * if a solution not respecting the cutoff bound was found before installing a cutoff bound which
1592  * renders the remaining problem infeasible, this solution may be reported as optimal
1593  *
1594  * @pre This method can be called if SCIP is in one of the following stages:
1595  * - \ref SCIP_STAGE_TRANSFORMED
1596  * - \ref SCIP_STAGE_PRESOLVING
1597  * - \ref SCIP_STAGE_PRESOLVED
1598  * - \ref SCIP_STAGE_INITSOLVE
1599  * - \ref SCIP_STAGE_SOLVING
1600  *
1601  * @note the given cutoff bound has to better or equal to known one (SCIPgetCutoffbound())
1602  * @note a given cutoff bound is also used for updating the objective limit, if possible
1603  */
1605  SCIP* scip, /**< SCIP data structure */
1606  SCIP_Real cutoffbound /**< new cutoff bound */
1607  )
1608 {
1609  SCIP_CALL( SCIPcheckStage(scip, "SCIPupdateCutoffbound", FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1610 
1611  assert(cutoffbound <= SCIPgetCutoffbound(scip));
1612 
1613  SCIP_CALL( SCIPprimalSetCutoffbound(scip->primal, scip->mem->probmem, scip->set, scip->stat, scip->eventfilter,
1614  scip->eventqueue, scip->transprob, scip->origprob, scip->tree, scip->reopt, scip->lp, cutoffbound, FALSE) );
1615 
1616  return SCIP_OKAY;
1617 }
1618 
1619 
1620 /** returns whether the current primal bound is justified with a feasible primal solution; if not, the primal bound
1621  * was set from the user as objective limit
1622  *
1623  * @return TRUE if the current primal bound is justified with a feasible primal solution, otherwise FALSE
1624  *
1625  * @pre This method can be called if SCIP is in one of the following stages:
1626  * - \ref SCIP_STAGE_TRANSFORMED
1627  * - \ref SCIP_STAGE_INITPRESOLVE
1628  * - \ref SCIP_STAGE_PRESOLVING
1629  * - \ref SCIP_STAGE_EXITPRESOLVE
1630  * - \ref SCIP_STAGE_PRESOLVED
1631  * - \ref SCIP_STAGE_INITSOLVE
1632  * - \ref SCIP_STAGE_SOLVING
1633  * - \ref SCIP_STAGE_SOLVED
1634  * - \ref SCIP_STAGE_EXITSOLVE
1635  */
1637  SCIP* scip /**< SCIP data structure */
1638  )
1639 {
1640  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPisPrimalboundSol", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1641 
1642  return SCIPprimalUpperboundIsSol(scip->primal, scip->set, scip->transprob, scip->origprob);
1643 }
1644 
1645 /** gets current gap |(primalbound - dualbound)/min(|primalbound|,|dualbound|)| if both bounds have same sign,
1646  * or infinity, if they have opposite sign
1647  *
1648  * @return the current gap |(primalbound - dualbound)/min(|primalbound|,|dualbound|)| if both bounds have same sign,
1649  * or infinity, if they have opposite sign
1650  *
1651  * @pre This method can be called if SCIP is in one of the following stages:
1652  * - \ref SCIP_STAGE_PRESOLVING
1653  * - \ref SCIP_STAGE_EXITPRESOLVE
1654  * - \ref SCIP_STAGE_PRESOLVED
1655  * - \ref SCIP_STAGE_INITSOLVE
1656  * - \ref SCIP_STAGE_SOLVING
1657  * - \ref SCIP_STAGE_SOLVED
1658  */
1660  SCIP* scip /**< SCIP data structure */
1661  )
1662 {
1664 
1665  /* in case we could not prove whether the problem is unbounded or infeasible, we want to terminate with gap = +inf;
1666  * if the problem was proven to be unbounded or proven to be infeasible we return gap = 0
1667  */
1668  if( SCIPgetStatus(scip) == SCIP_STATUS_INFORUNBD )
1669  return SCIPsetInfinity(scip->set);
1671  return 0.0;
1672 
1673  /* the lowerbound is infinity, but SCIP may not have updated the status; in this case, the problem was already solved
1674  * so we return gap = 0
1675  */
1676  if( SCIPsetIsInfinity(scip->set, SCIPgetLowerbound(scip)) )
1677  return 0.0;
1678 
1680 }
1681 
1682 /** gets current gap |(upperbound - lowerbound)/min(|upperbound|,|lowerbound|)| in transformed problem if both bounds
1683  * have same sign, or infinity, if they have opposite sign
1684  *
1685  * @return current gap |(upperbound - lowerbound)/min(|upperbound|,|lowerbound|)| in transformed problem if both bounds
1686  * have same sign, or infinity, if they have opposite sign
1687  *
1688  * @pre This method can be called if SCIP is in one of the following stages:
1689  * - \ref SCIP_STAGE_PRESOLVED
1690  * - \ref SCIP_STAGE_SOLVING
1691  * - \ref SCIP_STAGE_SOLVED
1692  */
1694  SCIP* scip /**< SCIP data structure */
1695  )
1696 {
1697  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetTransGap", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1698 
1699  /* in case we could not prove whether the problem is unbounded or infeasible, we want to terminate with gap = +inf;
1700  * if the problem was proven to be unbounded or proven to be infeasible we return gap = 0
1701  */
1702  if( SCIPgetStatus(scip) == SCIP_STATUS_INFORUNBD )
1703  return SCIPsetInfinity(scip->set);
1705  return 0.0;
1706 
1707  /* the lowerbound is infinity, but SCIP may not have updated the status; in this case, the problem was already solved
1708  * so we return gap = 0
1709  */
1710  if( SCIPsetIsInfinity(scip->set, SCIPgetLowerbound(scip)) )
1711  return 0.0;
1712 
1714 }
1715 
1716 /** gets number of feasible primal solutions found so far
1717  *
1718  * @return the number of feasible primal solutions found so far
1719  *
1720  * @pre This method can be called if SCIP is in one of the following stages:
1721  * - \ref SCIP_STAGE_TRANSFORMED
1722  * - \ref SCIP_STAGE_INITPRESOLVE
1723  * - \ref SCIP_STAGE_PRESOLVING
1724  * - \ref SCIP_STAGE_EXITPRESOLVE
1725  * - \ref SCIP_STAGE_PRESOLVED
1726  * - \ref SCIP_STAGE_INITSOLVE
1727  * - \ref SCIP_STAGE_SOLVING
1728  * - \ref SCIP_STAGE_SOLVED
1729  * - \ref SCIP_STAGE_EXITSOLVE
1730  */
1732  SCIP* scip /**< SCIP data structure */
1733  )
1734 {
1735  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNSolsFound", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1736 
1737  return scip->primal->nsolsfound;
1738 }
1739 
1740 /** gets number of feasible primal solutions respecting the objective limit found so far
1741  *
1742  * @return the number of feasible primal solutions respecting the objective limit found so far
1743  *
1744  * @pre This method can be called if SCIP is in one of the following stages:
1745  * - \ref SCIP_STAGE_INIT
1746  * - \ref SCIP_STAGE_PROBLEM
1747  * - \ref SCIP_STAGE_TRANSFORMING
1748  * - \ref SCIP_STAGE_TRANSFORMED
1749  * - \ref SCIP_STAGE_INITPRESOLVE
1750  * - \ref SCIP_STAGE_PRESOLVING
1751  * - \ref SCIP_STAGE_EXITPRESOLVE
1752  * - \ref SCIP_STAGE_PRESOLVED
1753  * - \ref SCIP_STAGE_INITSOLVE
1754  * - \ref SCIP_STAGE_SOLVING
1755  * - \ref SCIP_STAGE_SOLVED
1756  * - \ref SCIP_STAGE_EXITSOLVE
1757  */
1759  SCIP* scip /**< SCIP data structure */
1760  )
1761 {
1763  return 0;
1764 
1765  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNLimSolsFound", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1766 
1767  return scip->primal->nlimsolsfound;
1768 }
1769 
1770 /** gets number of feasible primal solutions found so far, that improved the primal bound at the time they were found
1771  *
1772  * @return the number of feasible primal solutions found so far, that improved the primal bound at the time they were found
1773  *
1774  * @pre This method can be called if SCIP is in one of the following stages:
1775  * - \ref SCIP_STAGE_TRANSFORMED
1776  * - \ref SCIP_STAGE_INITPRESOLVE
1777  * - \ref SCIP_STAGE_PRESOLVING
1778  * - \ref SCIP_STAGE_EXITPRESOLVE
1779  * - \ref SCIP_STAGE_PRESOLVED
1780  * - \ref SCIP_STAGE_INITSOLVE
1781  * - \ref SCIP_STAGE_SOLVING
1782  * - \ref SCIP_STAGE_SOLVED
1783  * - \ref SCIP_STAGE_EXITSOLVE
1784  */
1786  SCIP* scip /**< SCIP data structure */
1787  )
1788 {
1789  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNBestSolsFound", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1790 
1791  return scip->primal->nbestsolsfound;
1792 }
1793 
1794 /** gets the average pseudo cost value for the given direction over all variables
1795  *
1796  * @return the average pseudo cost value for the given direction over all variables
1797  *
1798  * @pre This method can be called if SCIP is in one of the following stages:
1799  * - \ref SCIP_STAGE_SOLVING
1800  * - \ref SCIP_STAGE_SOLVED
1801  */
1803  SCIP* scip, /**< SCIP data structure */
1804  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
1805  )
1806 {
1807  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgPseudocost", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1808 
1809  return SCIPhistoryGetPseudocost(scip->stat->glbhistory, solvaldelta);
1810 }
1811 
1812 /** gets the average pseudo cost value for the given direction over all variables,
1813  * only using the pseudo cost information of the current run
1814  *
1815  * @return the average pseudo cost value for the given direction over all variables,
1816  * only using the pseudo cost information of the current run
1817  *
1818  * @pre This method can be called if SCIP is in one of the following stages:
1819  * - \ref SCIP_STAGE_SOLVING
1820  * - \ref SCIP_STAGE_SOLVED
1821  */
1823  SCIP* scip, /**< SCIP data structure */
1824  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
1825  )
1826 {
1827  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgPseudocostCurrentRun", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1828 
1829  return SCIPhistoryGetPseudocost(scip->stat->glbhistorycrun, solvaldelta);
1830 }
1831 
1832 /** gets the average number of pseudo cost updates for the given direction over all variables
1833  *
1834  * @return the average number of pseudo cost updates for the given direction over all variables
1835  *
1836  * @pre This method can be called if SCIP is in one of the following stages:
1837  * - \ref SCIP_STAGE_SOLVING
1838  * - \ref SCIP_STAGE_SOLVED
1839  */
1841  SCIP* scip, /**< SCIP data structure */
1842  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1843  )
1844 {
1845  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgPseudocostCount", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1846 
1847  return SCIPhistoryGetPseudocostCount(scip->stat->glbhistory, dir)
1848  / MAX(scip->transprob->nbinvars + scip->transprob->nintvars, 1);
1849 }
1850 
1851 /** gets the average number of pseudo cost updates for the given direction over all variables,
1852  * only using the pseudo cost information of the current run
1853  *
1854  * @return the average number of pseudo cost updates for the given direction over all variables,
1855  * only using the pseudo cost information of the current run
1856  *
1857  * @pre This method can be called if SCIP is in one of the following stages:
1858  * - \ref SCIP_STAGE_SOLVING
1859  * - \ref SCIP_STAGE_SOLVED
1860  */
1862  SCIP* scip, /**< SCIP data structure */
1863  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1864  )
1865 {
1866  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgPseudocostCountCurrentRun", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1867 
1869  / MAX(scip->transprob->nbinvars + scip->transprob->nintvars, 1);
1870 }
1871 
1872 /** gets the average pseudo cost score value over all variables, assuming a fractionality of 0.5
1873  *
1874  * @return the average pseudo cost score value over all variables, assuming a fractionality of 0.5
1875  *
1876  * @pre This method can be called if SCIP is in one of the following stages:
1877  * - \ref SCIP_STAGE_SOLVING
1878  * - \ref SCIP_STAGE_SOLVED
1879  */
1881  SCIP* scip /**< SCIP data structure */
1882  )
1883 {
1884  SCIP_Real pscostdown;
1885  SCIP_Real pscostup;
1886 
1887  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgPseudocostScore", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1888 
1889  pscostdown = SCIPhistoryGetPseudocost(scip->stat->glbhistory, -0.5);
1890  pscostup = SCIPhistoryGetPseudocost(scip->stat->glbhistory, +0.5);
1891 
1892  return SCIPbranchGetScore(scip->set, NULL, pscostdown, pscostup);
1893 }
1894 
1895 /** returns the variance of pseudo costs for all variables in the requested direction
1896  *
1897  * @return the variance of pseudo costs for all variables in the requested direction
1898  *
1899  * @pre This method can be called if SCIP is in one of the following stages:
1900  * - \ref SCIP_STAGE_SOLVING
1901  * - \ref SCIP_STAGE_SOLVED
1902  */
1904  SCIP* scip, /**< SCIP data structure */
1905  SCIP_BRANCHDIR branchdir, /**< the branching direction, up or down */
1906  SCIP_Bool onlycurrentrun /**< use only history of current run? */
1907  )
1908 {
1909  SCIP_HISTORY* history;
1910 
1911  assert(scip != NULL);
1912  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetPseudocostVariance", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1913 
1914  history = (onlycurrentrun ? scip->stat->glbhistorycrun : scip->stat->glbhistory);
1915  assert(history != NULL);
1916 
1917  return SCIPhistoryGetPseudocostVariance(history, branchdir);
1918 }
1919 
1920 /** gets the number of pseudo cost updates for the given direction over all variables
1921  *
1922  * @return the number of pseudo cost updates for the given direction over all variables
1923  *
1924  * @pre This method can be called if SCIP is in one of the following stages:
1925  * - \ref SCIP_STAGE_SOLVING
1926  * - \ref SCIP_STAGE_SOLVED
1927  */
1929  SCIP* scip, /**< SCIP data structure */
1930  SCIP_BRANCHDIR dir, /**< branching direction (downwards, or upwards) */
1931  SCIP_Bool onlycurrentrun /**< use only history of current run? */
1932  )
1933 {
1934  SCIP_HISTORY* history;
1935 
1936  assert(scip != NULL);
1937  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetPseudocostCount", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1938 
1939  history = (onlycurrentrun ? scip->stat->glbhistorycrun : scip->stat->glbhistory);
1940 
1941  return SCIPhistoryGetPseudocostCount(history, dir);
1942 }
1943 
1944 /** gets the average pseudo cost score value over all variables, assuming a fractionality of 0.5,
1945  * only using the pseudo cost information of the current run
1946  *
1947  * @return the average pseudo cost score value over all variables, assuming a fractionality of 0.5,
1948  * only using the pseudo cost information of the current run
1949  *
1950  * @pre This method can be called if SCIP is in one of the following stages:
1951  * - \ref SCIP_STAGE_SOLVING
1952  * - \ref SCIP_STAGE_SOLVED
1953  */
1955  SCIP* scip /**< SCIP data structure */
1956  )
1957 {
1958  SCIP_Real pscostdown;
1959  SCIP_Real pscostup;
1960 
1961  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgPseudocostScoreCurrentRun", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1962 
1963  pscostdown = SCIPhistoryGetPseudocost(scip->stat->glbhistorycrun, -0.5);
1964  pscostup = SCIPhistoryGetPseudocost(scip->stat->glbhistorycrun, +0.5);
1965 
1966  return SCIPbranchGetScore(scip->set, NULL, pscostdown, pscostup);
1967 }
1968 
1969 /** gets the average conflict score value over all variables
1970  *
1971  * @return the average conflict score value over all variables
1972  *
1973  * @pre This method can be called if SCIP is in one of the following stages:
1974  * - \ref SCIP_STAGE_SOLVING
1975  * - \ref SCIP_STAGE_SOLVED
1976  */
1978  SCIP* scip /**< SCIP data structure */
1979  )
1980 {
1981  SCIP_Real conflictscoredown;
1982  SCIP_Real conflictscoreup;
1983  SCIP_Real scale;
1984 
1985  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgConflictScore", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1986 
1987  scale = scip->transprob->nvars * scip->stat->vsidsweight;
1988  conflictscoredown = SCIPhistoryGetVSIDS(scip->stat->glbhistory, SCIP_BRANCHDIR_DOWNWARDS) / scale;
1989  conflictscoreup = SCIPhistoryGetVSIDS(scip->stat->glbhistory, SCIP_BRANCHDIR_UPWARDS) / scale;
1990 
1991  return SCIPbranchGetScore(scip->set, NULL, conflictscoredown, conflictscoreup);
1992 }
1993 
1994 /** gets the average conflict score value over all variables, only using the conflict score information of the current run
1995  *
1996  * @return the average conflict score value over all variables, only using the conflict score information of the current run
1997  *
1998  * @pre This method can be called if SCIP is in one of the following stages:
1999  * - \ref SCIP_STAGE_SOLVING
2000  * - \ref SCIP_STAGE_SOLVED
2001  */
2003  SCIP* scip /**< SCIP data structure */
2004  )
2005 {
2006  SCIP_Real conflictscoredown;
2007  SCIP_Real conflictscoreup;
2008  SCIP_Real scale;
2009 
2010  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgConflictScoreCurrentRun", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2011 
2012  scale = scip->transprob->nvars * scip->stat->vsidsweight;
2013  conflictscoredown = SCIPhistoryGetVSIDS(scip->stat->glbhistorycrun, SCIP_BRANCHDIR_DOWNWARDS) / scale;
2014  conflictscoreup = SCIPhistoryGetVSIDS(scip->stat->glbhistorycrun, SCIP_BRANCHDIR_UPWARDS) / scale;
2015 
2016  return SCIPbranchGetScore(scip->set, NULL, conflictscoredown, conflictscoreup);
2017 }
2018 
2019 /** gets the average inference score value over all variables
2020  *
2021  * @return the average inference score value over all variables
2022  *
2023  * @pre This method can be called if SCIP is in one of the following stages:
2024  * - \ref SCIP_STAGE_SOLVING
2025  * - \ref SCIP_STAGE_SOLVED
2026  */
2028  SCIP* scip /**< SCIP data structure */
2029  )
2030 {
2031  SCIP_Real conflictlengthdown;
2032  SCIP_Real conflictlengthup;
2033 
2034  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgConflictlengthScore", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2035 
2038 
2039  return SCIPbranchGetScore(scip->set, NULL, conflictlengthdown, conflictlengthup);
2040 }
2041 
2042 /** gets the average conflictlength score value over all variables, only using the conflictlength information of the
2043  * current run
2044  *
2045  * @return the average conflictlength score value over all variables, only using the conflictlength information of the
2046  * current run
2047  *
2048  * @pre This method can be called if SCIP is in one of the following stages:
2049  * - \ref SCIP_STAGE_SOLVING
2050  * - \ref SCIP_STAGE_SOLVED
2051  */
2053  SCIP* scip /**< SCIP data structure */
2054  )
2055 {
2056  SCIP_Real conflictlengthdown;
2057  SCIP_Real conflictlengthup;
2058 
2059  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgConflictlengthScoreCurrentRun", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2060 
2063 
2064  return SCIPbranchGetScore(scip->set, NULL, conflictlengthdown, conflictlengthup);
2065 }
2066 
2067 /** returns the average number of inferences found after branching in given direction over all variables
2068  *
2069  * @return the average number of inferences found after branching in given direction over all variables
2070  *
2071  * @pre This method can be called if SCIP is in one of the following stages:
2072  * - \ref SCIP_STAGE_SOLVING
2073  * - \ref SCIP_STAGE_SOLVED
2074  */
2076  SCIP* scip, /**< SCIP data structure */
2077  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
2078  )
2079 {
2080  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgInferences", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2081 
2082  return SCIPhistoryGetAvgInferences(scip->stat->glbhistory, dir);
2083 }
2084 
2085 /** returns the average number of inferences found after branching in given direction over all variables,
2086  * only using the inference information of the current run
2087  *
2088  * @return the average number of inferences found after branching in given direction over all variables,
2089  * only using the inference information of the current run
2090  *
2091  * @pre This method can be called if SCIP is in one of the following stages:
2092  * - \ref SCIP_STAGE_SOLVING
2093  * - \ref SCIP_STAGE_SOLVED
2094  */
2096  SCIP* scip, /**< SCIP data structure */
2097  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
2098  )
2099 {
2100  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgInferencesCurrentRun", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2101 
2102  return SCIPhistoryGetAvgInferences(scip->stat->glbhistorycrun, dir);
2103 }
2104 
2105 /** gets the average inference score value over all variables
2106  *
2107  * @return the average inference score value over all variables
2108  *
2109  * @pre This method can be called if SCIP is in one of the following stages:
2110  * - \ref SCIP_STAGE_SOLVING
2111  * - \ref SCIP_STAGE_SOLVED
2112  */
2114  SCIP* scip /**< SCIP data structure */
2115  )
2116 {
2117  SCIP_Real inferencesdown;
2118  SCIP_Real inferencesup;
2119 
2120  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgInferenceScore", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2121 
2124 
2125  return SCIPbranchGetScore(scip->set, NULL, inferencesdown, inferencesup);
2126 }
2127 
2128 /** gets the average inference score value over all variables, only using the inference information of the
2129  * current run
2130  *
2131  * @return the average inference score value over all variables, only using the inference information of the
2132  * current run
2133  *
2134  * @pre This method can be called if SCIP is in one of the following stages:
2135  * - \ref SCIP_STAGE_SOLVING
2136  * - \ref SCIP_STAGE_SOLVED
2137  */
2139  SCIP* scip /**< SCIP data structure */
2140  )
2141 {
2142  SCIP_Real inferencesdown;
2143  SCIP_Real inferencesup;
2144 
2145  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgInferenceScoreCurrentRun", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2146 
2149 
2150  return SCIPbranchGetScore(scip->set, NULL, inferencesdown, inferencesup);
2151 }
2152 
2153 /** returns the average number of cutoffs found after branching in given direction over all variables
2154  *
2155  * @return the average number of cutoffs found after branching in given direction over all variables
2156  *
2157  * @pre This method can be called if SCIP is in one of the following stages:
2158  * - \ref SCIP_STAGE_SOLVING
2159  * - \ref SCIP_STAGE_SOLVED
2160  */
2162  SCIP* scip, /**< SCIP data structure */
2163  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
2164  )
2165 {
2166  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgCutoffs", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2167 
2168  return SCIPhistoryGetAvgCutoffs(scip->stat->glbhistory, dir);
2169 }
2170 
2171 /** returns the average number of cutoffs found after branching in given direction over all variables,
2172  * only using the cutoff information of the current run
2173  *
2174  * @return the average number of cutoffs found after branching in given direction over all variables,
2175  * only using the cutoff information of the current run
2176  *
2177  * @pre This method can be called if SCIP is in one of the following stages:
2178  * - \ref SCIP_STAGE_SOLVING
2179  * - \ref SCIP_STAGE_SOLVED
2180  */
2182  SCIP* scip, /**< SCIP data structure */
2183  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
2184  )
2185 {
2186  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgCutoffsCurrentRun", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2187 
2188  return SCIPhistoryGetAvgCutoffs(scip->stat->glbhistorycrun, dir);
2189 }
2190 
2191 /** gets the average cutoff score value over all variables
2192  *
2193  * @return the average cutoff score value over all variables
2194  *
2195  * @pre This method can be called if SCIP is in one of the following stages:
2196  * - \ref SCIP_STAGE_SOLVING
2197  * - \ref SCIP_STAGE_SOLVED
2198  */
2200  SCIP* scip /**< SCIP data structure */
2201  )
2202 {
2203  SCIP_Real cutoffsdown;
2204  SCIP_Real cutoffsup;
2205 
2206  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgCutoffScore", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2207 
2210 
2211  return SCIPbranchGetScore(scip->set, NULL, cutoffsdown, cutoffsup);
2212 }
2213 
2214 /** gets the average cutoff score value over all variables, only using the cutoff score information of the current run
2215  *
2216  * @return the average cutoff score value over all variables, only using the cutoff score information of the current run
2217  *
2218  * @pre This method can be called if SCIP is in one of the following stages:
2219  * - \ref SCIP_STAGE_SOLVING
2220  * - \ref SCIP_STAGE_SOLVED
2221  */
2223  SCIP* scip /**< SCIP data structure */
2224  )
2225 {
2226  SCIP_Real cutoffsdown;
2227  SCIP_Real cutoffsup;
2228 
2229  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgCutoffScoreCurrentRun", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2230 
2233 
2234  return SCIPbranchGetScore(scip->set, NULL, cutoffsdown, cutoffsup);
2235 }
2236 
2237 /** computes a deterministic measure of time from statistics
2238  *
2239  * @return the deterministic time
2240  *
2241  * @pre This method can be called if SCIP is in one of the following stages:
2242  * - \ref SCIP_STAGE_PRESOLVING
2243  * - \ref SCIP_STAGE_PRESOLVED
2244  * - \ref SCIP_STAGE_SOLVING
2245  * - \ref SCIP_STAGE_SOLVED
2246  */
2248  SCIP* scip /**< SCIP data structure */
2249  )
2250 {
2251 /* TODO: SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetDeterministicTime", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) ); */
2252  if(scip->stat == NULL)
2253  return 0.0;
2254 
2255  return 1e-6 * scip->stat->nnz * (
2256  0.00328285264101 * scip->stat->nprimalresolvelpiterations +
2257  0.00531625104146 * scip->stat->ndualresolvelpiterations +
2258  0.000738719124051 * scip->stat->nprobboundchgs +
2259  0.0011123144764 * scip->stat->nisstoppedcalls );
2260 }
2261 
2262 /** outputs problem to file stream */
2263 static
2265  SCIP* scip, /**< SCIP data structure */
2266  SCIP_PROB* prob, /**< problem data */
2267  FILE* file, /**< output file (or NULL for standard output) */
2268  const char* extension, /**< file format (or NULL for default CIP format) */
2269  SCIP_Bool genericnames /**< using generic variable and constraint names? */
2270  )
2271 {
2272  SCIP_RESULT result;
2273  int i;
2274  assert(scip != NULL);
2275  assert(prob != NULL);
2276 
2277  /* try all readers until one could read the file */
2278  result = SCIP_DIDNOTRUN;
2279  for( i = 0; i < scip->set->nreaders && result == SCIP_DIDNOTRUN; ++i )
2280  {
2281  SCIP_RETCODE retcode;
2282 
2283  if( extension != NULL )
2284  retcode = SCIPreaderWrite(scip->set->readers[i], prob, scip->set, file, extension, genericnames, &result);
2285  else
2286  retcode = SCIPreaderWrite(scip->set->readers[i], prob, scip->set, file, "cip", genericnames, &result);
2287 
2288  /* check for reader errors */
2289  if( retcode == SCIP_WRITEERROR )
2290  return retcode;
2291 
2292  SCIP_CALL( retcode );
2293  }
2294 
2295  switch( result )
2296  {
2297  case SCIP_DIDNOTRUN:
2298  return SCIP_PLUGINNOTFOUND;
2299 
2300  case SCIP_SUCCESS:
2301  return SCIP_OKAY;
2302 
2303  default:
2304  assert(i < scip->set->nreaders);
2305  SCIPerrorMessage("invalid result code <%d> from reader <%s> writing <%s> format\n",
2306  result, SCIPreaderGetName(scip->set->readers[i]), extension);
2307  return SCIP_READERROR;
2308  } /*lint !e788*/
2309 }
2310 
2311 /** outputs original problem to file stream
2312  *
2313  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2314  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2315  *
2316  * @pre This method can be called if SCIP is in one of the following stages:
2317  * - \ref SCIP_STAGE_PROBLEM
2318  * - \ref SCIP_STAGE_TRANSFORMING
2319  * - \ref SCIP_STAGE_TRANSFORMED
2320  * - \ref SCIP_STAGE_INITPRESOLVE
2321  * - \ref SCIP_STAGE_PRESOLVING
2322  * - \ref SCIP_STAGE_EXITPRESOLVE
2323  * - \ref SCIP_STAGE_PRESOLVED
2324  * - \ref SCIP_STAGE_INITSOLVE
2325  * - \ref SCIP_STAGE_SOLVING
2326  * - \ref SCIP_STAGE_SOLVED
2327  * - \ref SCIP_STAGE_EXITSOLVE
2328  * - \ref SCIP_STAGE_FREETRANS
2329  */
2331  SCIP* scip, /**< SCIP data structure */
2332  FILE* file, /**< output file (or NULL for standard output) */
2333  const char* extension, /**< file format (or NULL for default CIP format)*/
2334  SCIP_Bool genericnames /**< using generic variable and constraint names? */
2335  )
2336 {
2337  SCIP_RETCODE retcode;
2338 
2339  SCIP_CALL( SCIPcheckStage(scip, "SCIPprintOrigProblem", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
2340 
2341  assert(scip != NULL);
2342  assert( scip->origprob != NULL );
2343 
2344  retcode = printProblem(scip, scip->origprob, file, extension, genericnames);
2345 
2346  /* check for write errors */
2347  if( retcode == SCIP_WRITEERROR || retcode == SCIP_PLUGINNOTFOUND )
2348  return retcode;
2349  else
2350  {
2351  SCIP_CALL( retcode );
2352  }
2353 
2354  return SCIP_OKAY;
2355 }
2356 
2357 /** outputs transformed problem of the current node to file stream
2358  *
2359  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2360  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2361  *
2362  * @pre This method can be called if SCIP is in one of the following stages:
2363  * - \ref SCIP_STAGE_TRANSFORMED
2364  * - \ref SCIP_STAGE_INITPRESOLVE
2365  * - \ref SCIP_STAGE_PRESOLVING
2366  * - \ref SCIP_STAGE_EXITPRESOLVE
2367  * - \ref SCIP_STAGE_PRESOLVED
2368  * - \ref SCIP_STAGE_INITSOLVE
2369  * - \ref SCIP_STAGE_SOLVING
2370  * - \ref SCIP_STAGE_SOLVED
2371  * - \ref SCIP_STAGE_EXITSOLVE
2372  * - \ref SCIP_STAGE_FREETRANS
2373  */
2375  SCIP* scip, /**< SCIP data structure */
2376  FILE* file, /**< output file (or NULL for standard output) */
2377  const char* extension, /**< file format (or NULL for default CIP format)*/
2378  SCIP_Bool genericnames /**< using generic variable and constraint names? */
2379  )
2380 {
2381  SCIP_RETCODE retcode;
2382 
2383  SCIP_CALL( SCIPcheckStage(scip, "SCIPprintTransProblem", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
2384 
2385  assert(scip != NULL);
2386  assert(scip->transprob != NULL );
2387 
2388  retcode = printProblem(scip, scip->transprob, file, extension, genericnames);
2389 
2390  /* check for write errors */
2391  if( retcode == SCIP_WRITEERROR || retcode == SCIP_PLUGINNOTFOUND )
2392  return retcode;
2393  else
2394  {
2395  SCIP_CALL( retcode );
2396  }
2397 
2398  return SCIP_OKAY;
2399 }
2400 
2401 /** outputs status statistics
2402  *
2403  * @note If limits have been changed between the solution and the call to this function, the status is recomputed and
2404  * thus may to correspond to the original status.
2405  *
2406  * @pre This method can be called if SCIP is in one of the following stages:
2407  * - \ref SCIP_STAGE_INIT
2408  * - \ref SCIP_STAGE_PROBLEM
2409  * - \ref SCIP_STAGE_TRANSFORMED
2410  * - \ref SCIP_STAGE_INITPRESOLVE
2411  * - \ref SCIP_STAGE_PRESOLVING
2412  * - \ref SCIP_STAGE_EXITPRESOLVE
2413  * - \ref SCIP_STAGE_PRESOLVED
2414  * - \ref SCIP_STAGE_SOLVING
2415  * - \ref SCIP_STAGE_SOLVED
2416  */
2418  SCIP* scip, /**< SCIP data structure */
2419  FILE* file /**< output file */
2420  )
2421 {
2422  assert(scip != NULL);
2423  assert(scip->set != NULL);
2424 
2425  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintStatusStatistics", TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2426 
2427  SCIPmessageFPrintInfo(scip->messagehdlr, file, "SCIP Status : ");
2428  SCIP_CALL_ABORT( SCIPprintStage(scip, file) );
2429  SCIPmessageFPrintInfo(scip->messagehdlr, file, "\n");
2430 }
2431 
2432 /** outputs statistics for original problem
2433  *
2434  * @pre This method can be called if SCIP is in one of the following stages:
2435  * - \ref SCIP_STAGE_PROBLEM
2436  * - \ref SCIP_STAGE_TRANSFORMED
2437  * - \ref SCIP_STAGE_INITPRESOLVE
2438  * - \ref SCIP_STAGE_PRESOLVING
2439  * - \ref SCIP_STAGE_EXITPRESOLVE
2440  * - \ref SCIP_STAGE_PRESOLVED
2441  * - \ref SCIP_STAGE_SOLVING
2442  * - \ref SCIP_STAGE_SOLVED
2443  */
2445  SCIP* scip, /**< SCIP data structure */
2446  FILE* file /**< output file */
2447  )
2448 {
2449  assert(scip != NULL);
2450  assert(scip->set != NULL);
2451 
2452  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintOrigProblemStatistics", FALSE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2453 
2454  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Original Problem :\n");
2455  SCIPprobPrintStatistics(scip->origprob, scip->set, scip->messagehdlr, file);
2456 }
2457 
2458 /** outputs statistics for transformed problem
2459  *
2460  * @pre This method can be called if SCIP is in one of the following stages:
2461  * - \ref SCIP_STAGE_PROBLEM
2462  * - \ref SCIP_STAGE_TRANSFORMED
2463  * - \ref SCIP_STAGE_INITPRESOLVE
2464  * - \ref SCIP_STAGE_PRESOLVING
2465  * - \ref SCIP_STAGE_EXITPRESOLVE
2466  * - \ref SCIP_STAGE_PRESOLVED
2467  * - \ref SCIP_STAGE_SOLVING
2468  * - \ref SCIP_STAGE_SOLVED
2469  */
2471  SCIP* scip, /**< SCIP data structure */
2472  FILE* file /**< output file */
2473  )
2474 {
2475  assert(scip != NULL);
2476  assert(scip->set != NULL);
2477 
2478  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintTransProblemStatistics", FALSE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2479 
2480  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Presolved Problem :\n");
2481  SCIPprobPrintStatistics(scip->transprob, scip->set, scip->messagehdlr, file);
2482  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Nonzeros : %" SCIP_LONGINT_FORMAT " constraint, %" SCIP_LONGINT_FORMAT " clique table\n",
2484 }
2485 
2486 /** outputs presolver statistics
2487  *
2488  * @pre This method can be called if SCIP is in one of the following stages:
2489  * - \ref SCIP_STAGE_TRANSFORMED
2490  * - \ref SCIP_STAGE_INITPRESOLVE
2491  * - \ref SCIP_STAGE_PRESOLVING
2492  * - \ref SCIP_STAGE_EXITPRESOLVE
2493  * - \ref SCIP_STAGE_PRESOLVED
2494  * - \ref SCIP_STAGE_SOLVING
2495  * - \ref SCIP_STAGE_SOLVED
2496  */
2498  SCIP* scip, /**< SCIP data structure */
2499  FILE* file /**< output file */
2500  )
2501 {
2502  int i;
2503 
2504  assert(scip != NULL);
2505  assert(scip->set != NULL);
2506 
2507  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintPresolverStatistics", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2508 
2509  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Presolvers : ExecTime SetupTime Calls FixedVars AggrVars ChgTypes ChgBounds AddHoles DelCons AddCons ChgSides ChgCoefs\n");
2510 
2511  /* sort presolvers w.r.t. their name */
2512  SCIPsetSortPresolsName(scip->set);
2513 
2514  /* presolver statistics */
2515  for( i = 0; i < scip->set->npresols; ++i )
2516  {
2517  SCIP_PRESOL* presol;
2518  presol = scip->set->presols[i];
2519  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s:", SCIPpresolGetName(presol));
2520  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f %10.2f %6d %10d %10d %10d %10d %10d %10d %10d %10d %10d\n",
2521  SCIPpresolGetTime(presol),
2522  SCIPpresolGetSetupTime(presol),
2523  SCIPpresolGetNCalls(presol),
2524  SCIPpresolGetNFixedVars(presol),
2525  SCIPpresolGetNAggrVars(presol),
2526  SCIPpresolGetNChgVarTypes(presol),
2527  SCIPpresolGetNChgBds(presol),
2528  SCIPpresolGetNAddHoles(presol),
2529  SCIPpresolGetNDelConss(presol),
2530  SCIPpresolGetNAddConss(presol),
2531  SCIPpresolGetNChgSides(presol),
2532  SCIPpresolGetNChgCoefs(presol));
2533  }
2534 
2535  /* sort propagators w.r.t. their name */
2536  SCIPsetSortPropsName(scip->set);
2537 
2538  for( i = 0; i < scip->set->nprops; ++i )
2539  {
2540  SCIP_PROP* prop;
2541  prop = scip->set->props[i];
2542  if( SCIPpropDoesPresolve(prop) )
2543  {
2544  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s:", SCIPpropGetName(prop));
2545  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f %10.2f %6d %10d %10d %10d %10d %10d %10d %10d %10d %10d\n",
2546  SCIPpropGetPresolTime(prop),
2547  SCIPpropGetSetupTime(prop),
2549  SCIPpropGetNFixedVars(prop),
2550  SCIPpropGetNAggrVars(prop),
2552  SCIPpropGetNChgBds(prop),
2553  SCIPpropGetNAddHoles(prop),
2554  SCIPpropGetNDelConss(prop),
2555  SCIPpropGetNAddConss(prop),
2556  SCIPpropGetNChgSides(prop),
2557  SCIPpropGetNChgCoefs(prop));
2558  }
2559  }
2560 
2561  /* constraint handler presolving methods statistics */
2562  for( i = 0; i < scip->set->nconshdlrs; ++i )
2563  {
2564  SCIP_CONSHDLR* conshdlr;
2565  int maxnactiveconss;
2566 
2567  conshdlr = scip->set->conshdlrs[i];
2568  maxnactiveconss = SCIPconshdlrGetMaxNActiveConss(conshdlr);
2569  if( SCIPconshdlrDoesPresolve(conshdlr)
2570  && (maxnactiveconss > 0 || !SCIPconshdlrNeedsCons(conshdlr)
2571  || SCIPconshdlrGetNFixedVars(conshdlr) > 0
2572  || SCIPconshdlrGetNAggrVars(conshdlr) > 0
2573  || SCIPconshdlrGetNChgVarTypes(conshdlr) > 0
2574  || SCIPconshdlrGetNChgBds(conshdlr) > 0
2575  || SCIPconshdlrGetNAddHoles(conshdlr) > 0
2576  || SCIPconshdlrGetNDelConss(conshdlr) > 0
2577  || SCIPconshdlrGetNAddConss(conshdlr) > 0
2578  || SCIPconshdlrGetNChgSides(conshdlr) > 0
2579  || SCIPconshdlrGetNChgCoefs(conshdlr) > 0
2580  || SCIPconshdlrGetNUpgdConss(conshdlr) > 0) )
2581  {
2582  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s:", SCIPconshdlrGetName(conshdlr));
2583  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f %10.2f %6d %10d %10d %10d %10d %10d %10d %10d %10d %10d\n",
2584  SCIPconshdlrGetPresolTime(conshdlr),
2585  SCIPconshdlrGetSetupTime(conshdlr),
2586  SCIPconshdlrGetNPresolCalls(conshdlr),
2587  SCIPconshdlrGetNFixedVars(conshdlr),
2588  SCIPconshdlrGetNAggrVars(conshdlr),
2589  SCIPconshdlrGetNChgVarTypes(conshdlr),
2590  SCIPconshdlrGetNChgBds(conshdlr),
2591  SCIPconshdlrGetNAddHoles(conshdlr),
2592  SCIPconshdlrGetNDelConss(conshdlr),
2593  SCIPconshdlrGetNAddConss(conshdlr),
2594  SCIPconshdlrGetNChgSides(conshdlr),
2595  SCIPconshdlrGetNChgCoefs(conshdlr));
2596  }
2597  }
2598 
2599  /* root node bound changes */
2600  SCIPmessageFPrintInfo(scip->messagehdlr, file, " root node : - - - %10d - - %10d - - - - -\n",
2601  scip->stat->nrootintfixings, scip->stat->nrootboundchgs);
2602 }
2603 
2604 /** outputs constraint statistics
2605  *
2606  * @pre This method can be called if SCIP is in one of the following stages:
2607  * - \ref SCIP_STAGE_TRANSFORMED
2608  * - \ref SCIP_STAGE_INITPRESOLVE
2609  * - \ref SCIP_STAGE_PRESOLVING
2610  * - \ref SCIP_STAGE_EXITPRESOLVE
2611  * - \ref SCIP_STAGE_PRESOLVED
2612  * - \ref SCIP_STAGE_SOLVING
2613  * - \ref SCIP_STAGE_SOLVED
2614  */
2616  SCIP* scip, /**< SCIP data structure */
2617  FILE* file /**< output file */
2618  )
2619 {
2620  int i;
2621 
2622  assert(scip != NULL);
2623  assert(scip->set != NULL);
2624 
2625  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintConstraintStatistics", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2626 
2627  /* Add maximal number of constraints of the same type? So far this information is not added because of lack of space. */
2628  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Constraints : Number MaxNumber #Separate #Propagate #EnfoLP #EnfoRelax #EnfoPS #Check #ResProp Cutoffs DomReds Cuts Applied Conss Children\n");
2629 
2630  for( i = 0; i < scip->set->nconshdlrs; ++i )
2631  {
2632  SCIP_CONSHDLR* conshdlr;
2633  int startnactiveconss;
2634  int maxnactiveconss;
2635 
2636  conshdlr = scip->set->conshdlrs[i];
2637  startnactiveconss = SCIPconshdlrGetStartNActiveConss(conshdlr);
2638  maxnactiveconss = SCIPconshdlrGetMaxNActiveConss(conshdlr);
2639  if( maxnactiveconss > 0 || !SCIPconshdlrNeedsCons(conshdlr) )
2640  {
2641  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s:", SCIPconshdlrGetName(conshdlr));
2642  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",
2643  startnactiveconss,
2644  maxnactiveconss > startnactiveconss ? '+' : ' ',
2645  maxnactiveconss,
2646  SCIPconshdlrGetNSepaCalls(conshdlr),
2647  SCIPconshdlrGetNPropCalls(conshdlr),
2648  SCIPconshdlrGetNEnfoLPCalls(conshdlr),
2650  SCIPconshdlrGetNEnfoPSCalls(conshdlr),
2651  SCIPconshdlrGetNCheckCalls(conshdlr),
2652  SCIPconshdlrGetNRespropCalls(conshdlr),
2653  SCIPconshdlrGetNCutoffs(conshdlr),
2654  SCIPconshdlrGetNDomredsFound(conshdlr),
2655  SCIPconshdlrGetNCutsFound(conshdlr),
2656  SCIPconshdlrGetNCutsApplied(conshdlr),
2657  SCIPconshdlrGetNConssFound(conshdlr),
2658  SCIPconshdlrGetNChildren(conshdlr));
2659  }
2660  }
2661 }
2662 
2663 /** outputs constraint timing statistics
2664  *
2665  * @pre This method can be called if SCIP is in one of the following stages:
2666  * - \ref SCIP_STAGE_TRANSFORMED
2667  * - \ref SCIP_STAGE_INITPRESOLVE
2668  * - \ref SCIP_STAGE_PRESOLVING
2669  * - \ref SCIP_STAGE_EXITPRESOLVE
2670  * - \ref SCIP_STAGE_PRESOLVED
2671  * - \ref SCIP_STAGE_SOLVING
2672  * - \ref SCIP_STAGE_SOLVED
2673  */
2675  SCIP* scip, /**< SCIP data structure */
2676  FILE* file /**< output file */
2677  )
2678 {
2679  int i;
2680 
2681  assert(scip != NULL);
2682  assert(scip->set != NULL);
2683 
2684  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintConstraintTimingStatistics", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2685 
2686  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Constraint Timings : TotalTime SetupTime Separate Propagate EnfoLP EnfoPS EnfoRelax Check ResProp SB-Prop\n");
2687 
2688  for( i = 0; i < scip->set->nconshdlrs; ++i )
2689  {
2690  SCIP_CONSHDLR* conshdlr;
2691  int maxnactiveconss;
2692 
2693  conshdlr = scip->set->conshdlrs[i];
2694  maxnactiveconss = SCIPconshdlrGetMaxNActiveConss(conshdlr);
2695  if( maxnactiveconss > 0 || !SCIPconshdlrNeedsCons(conshdlr) )
2696  {
2697  SCIP_Real totaltime;
2698 
2699  totaltime = SCIPconshdlrGetSepaTime(conshdlr) + SCIPconshdlrGetPropTime(conshdlr)
2701  + SCIPconshdlrGetEnfoLPTime(conshdlr)
2702  + SCIPconshdlrGetEnfoPSTime(conshdlr)
2703  + SCIPconshdlrGetEnfoRelaxTime(conshdlr)
2704  + SCIPconshdlrGetCheckTime(conshdlr)
2705  + SCIPconshdlrGetRespropTime(conshdlr)
2706  + SCIPconshdlrGetSetupTime(conshdlr);
2707 
2708  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s:", SCIPconshdlrGetName(conshdlr));
2709  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",
2710  totaltime,
2711  SCIPconshdlrGetSetupTime(conshdlr),
2712  SCIPconshdlrGetSepaTime(conshdlr),
2713  SCIPconshdlrGetPropTime(conshdlr),
2714  SCIPconshdlrGetEnfoLPTime(conshdlr),
2715  SCIPconshdlrGetEnfoPSTime(conshdlr),
2716  SCIPconshdlrGetEnfoRelaxTime(conshdlr),
2717  SCIPconshdlrGetCheckTime(conshdlr),
2718  SCIPconshdlrGetRespropTime(conshdlr),
2720  }
2721  }
2722 }
2723 
2724 /** outputs propagator statistics
2725  *
2726  * @pre This method can be called if SCIP is in one of the following stages:
2727  * - \ref SCIP_STAGE_TRANSFORMED
2728  * - \ref SCIP_STAGE_INITPRESOLVE
2729  * - \ref SCIP_STAGE_PRESOLVING
2730  * - \ref SCIP_STAGE_EXITPRESOLVE
2731  * - \ref SCIP_STAGE_PRESOLVED
2732  * - \ref SCIP_STAGE_SOLVING
2733  * - \ref SCIP_STAGE_SOLVED
2734  */
2736  SCIP* scip, /**< SCIP data structure */
2737  FILE* file /**< output file */
2738  )
2739 {
2740  int i;
2741 
2742  assert(scip != NULL);
2743  assert(scip->set != NULL);
2744 
2745  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintPropagatorStatistics", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2746 
2747  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Propagators : #Propagate #ResProp Cutoffs DomReds\n");
2748 
2749  /* sort propagaters w.r.t. their name */
2750  SCIPsetSortPropsName(scip->set);
2751 
2752  for( i = 0; i < scip->set->nprops; ++i )
2753  {
2754  SCIP_PROP* prop;
2755  prop = scip->set->props[i];
2756 
2757  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s: %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT "\n",
2758  SCIPpropGetName(prop),
2759  SCIPpropGetNCalls(prop),
2761  SCIPpropGetNCutoffs(prop),
2762  SCIPpropGetNDomredsFound(prop));
2763  }
2764 
2765  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Propagator Timings : TotalTime SetupTime Presolve Propagate ResProp SB-Prop\n");
2766 
2767  for( i = 0; i < scip->set->nprops; ++i )
2768  {
2769  SCIP_PROP* prop;
2770  SCIP_Real totaltime;
2771 
2772  prop = scip->set->props[i];
2773  totaltime = SCIPpropGetPresolTime(prop) + SCIPpropGetTime(prop) + SCIPpropGetRespropTime(prop)
2775 
2776  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s:", SCIPpropGetName(prop));
2777  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f %10.2f %10.2f %10.2f %10.2f %10.2f\n",
2778  totaltime,
2779  SCIPpropGetSetupTime(prop),
2780  SCIPpropGetPresolTime(prop),
2781  SCIPpropGetTime(prop),
2782  SCIPpropGetRespropTime(prop),
2784  }
2785 }
2786 
2787 /** outputs conflict statistics
2788  *
2789  * @pre This method can be called if SCIP is in one of the following stages:
2790  * - \ref SCIP_STAGE_TRANSFORMED
2791  * - \ref SCIP_STAGE_INITPRESOLVE
2792  * - \ref SCIP_STAGE_PRESOLVING
2793  * - \ref SCIP_STAGE_EXITPRESOLVE
2794  * - \ref SCIP_STAGE_PRESOLVED
2795  * - \ref SCIP_STAGE_SOLVING
2796  * - \ref SCIP_STAGE_SOLVED
2797  */
2799  SCIP* scip, /**< SCIP data structure */
2800  FILE* file /**< output file */
2801  )
2802 {
2803  char initstoresize[SCIP_MAXSTRLEN];
2804  char maxstoresize[SCIP_MAXSTRLEN];
2805 
2806  assert(scip != NULL);
2807  assert(scip->set != NULL);
2808 
2809  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintConflictStatistics", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2810 
2811  if( scip->set->conf_maxstoresize == 0 )
2812  {
2813  (void)SCIPsnprintf(initstoresize, SCIP_MAXSTRLEN, "inf");
2814  (void)SCIPsnprintf(maxstoresize, SCIP_MAXSTRLEN, "inf");
2815  }
2816  else
2817  {
2818  int initsize = SCIPconflictstoreGetInitPoolSize(scip->conflictstore);
2819  int maxsize = SCIPconflictstoreGetMaxPoolSize(scip->conflictstore);
2820 
2821  if( maxsize == -1 )
2822  {
2823  (void)SCIPsnprintf(initstoresize, SCIP_MAXSTRLEN, "--");
2824  (void)SCIPsnprintf(maxstoresize, SCIP_MAXSTRLEN, "--");
2825  }
2826  else
2827  {
2828  assert(initsize >= 0);
2829  assert(maxsize >= 0);
2830 
2831  (void)SCIPsnprintf(initstoresize, SCIP_MAXSTRLEN, "%d", initsize);
2832  (void)SCIPsnprintf(maxstoresize, SCIP_MAXSTRLEN, "%d", maxsize);
2833  }
2834  }
2835  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);
2836  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",
2848  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",
2865  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",
2882  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",
2895  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",
2907  SCIPmessageFPrintInfo(scip->messagehdlr, file, " applied globally : %10.2f - - %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.1f - - %10" SCIP_LONGINT_FORMAT " - -\n",
2915  SCIPmessageFPrintInfo(scip->messagehdlr, file, " applied locally : - - - %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.1f - - %10" SCIP_LONGINT_FORMAT " - -\n",
2922 }
2923 
2924 /** outputs separator statistics
2925  *
2926  * Columns:
2927  * - RootCalls: The number of calls that happened at the root.
2928  * - FoundCuts: The total number of cuts generated by the separators.
2929  * Note: Cutpool-FoundCuts \f$= \sum_{i=1}^nsepas ( Foundcuts_i - DirectAdd_i )\f$.
2930  * - ViaPoolAdd: The total number of cuts added to the sepastore from the cutpool.
2931  * - DirectAdd: The total number of cuts added directly to the sepastore from the separator.
2932  * - Applied: The sum of all cuts from the separator that were applied to the LP.
2933  * - ViaPoolApp: The number of cuts that entered the sepastore from the cutpool that were applied to the LP.
2934  * - DirectApp: The number of cuts that entered the sepastore directly and were applied to the LP.
2935  *
2936  * The number of cuts ViaPoolAdd + Directly should be equal to the number of cuts Filtered + Forced + Selected in the
2937  * cutselector statistics.
2938  *
2939  * @note The following edge case may lead to over or undercounting of statistics: When SCIPapplyCutsProbing() is
2940  * called, cuts are counted for the cut selection statistics, but not for the separator statistics. This
2941  * happens, e.g., in the default plugin prop_obbt.c.
2942  *
2943  * @pre This method can be called if SCIP is in one of the following stages:
2944  * - \ref SCIP_STAGE_SOLVING
2945  * - \ref SCIP_STAGE_SOLVED
2946  */
2948  SCIP* scip, /**< SCIP data structure */
2949  FILE* file /**< output file */
2950  )
2951 {
2952  int i;
2953 
2954  assert(scip != NULL);
2955  assert(scip->set != NULL);
2956 
2957  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintSeparatorStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2958 
2959  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Separators : ExecTime SetupTime Calls RootCalls Cutoffs DomReds FoundCuts ViaPoolAdd DirectAdd Applied ViaPoolApp DirectApp Conss\n");
2960  SCIPmessageFPrintInfo(scip->messagehdlr, file, " cut pool : %10.2f - %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " - - %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " - - - - - (maximal pool size: %10" SCIP_LONGINT_FORMAT")\n",
2961  SCIPcutpoolGetTime(scip->cutpool),
2967 
2968  /* sort separators w.r.t. their name */
2969  SCIPsetSortSepasName(scip->set);
2970 
2971  for( i = 0; i < scip->set->nsepas; ++i )
2972  {
2973  SCIP_SEPA* sepa;
2974 
2975  sepa = scip->set->sepas[i];
2976 
2977  /* only output data for separators without parent separator */
2978  if( SCIPsepaGetParentsepa(sepa) == NULL )
2979  {
2980 
2981  /* output data */
2982  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 " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT "\n",
2983  SCIPsepaGetName(sepa),
2984  SCIPsepaGetTime(sepa),
2985  SCIPsepaGetSetupTime(sepa),
2986  SCIPsepaGetNCalls(sepa),
2987  SCIPsepaGetNRootCalls(sepa),
2988  SCIPsepaGetNCutoffs(sepa),
2990  SCIPsepaGetNCutsFound(sepa),
2996  SCIPsepaGetNConssFound(sepa));
2997 
2998  /* for parent separators search for dependent separators */
2999  if( SCIPsepaIsParentsepa(sepa) )
3000  {
3001  SCIP_SEPA* parentsepa;
3002  int k;
3003 
3004  for( k = 0; k < scip->set->nsepas; ++k )
3005  {
3006  if( k == i )
3007  continue;
3008 
3009  parentsepa = SCIPsepaGetParentsepa(scip->set->sepas[k]);
3010  if( parentsepa != sepa )
3011  continue;
3012 
3013  SCIPmessageFPrintInfo(scip->messagehdlr, file, " > %-15.17s: %10s %10s %10s %10s %10s %10s %10s %10" SCIP_LONGINT_FORMAT" %10" SCIP_LONGINT_FORMAT" %10" SCIP_LONGINT_FORMAT" %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10s\n",
3014  SCIPsepaGetName(scip->set->sepas[k]), "-", "-", "-", "-", "-", "-", "-",
3017  SCIPsepaGetNCutsApplied(scip->set->sepas[k]),
3019  SCIPsepaGetNCutsAppliedDirect(scip->set->sepas[k]), "-");
3020  }
3021  }
3022  }
3023  }
3024 }
3025 
3026 /** outputs cutselector statistics
3027  *
3028  * Filtered = ViaPoolAdd(Separators) + DirectAdd(Separators) - Selected - Cuts(Constraints)
3029  * Selected = Applied(Separators) + Applied(Constraints)
3030  *
3031  * @pre This method can be called if SCIP is in one of the following stages:
3032  * - \ref SCIP_STAGE_SOLVING
3033  * - \ref SCIP_STAGE_SOLVED
3034  */
3036  SCIP* scip, /**< SCIP data structure */
3037  FILE* file /**< output file */
3038  )
3039 {
3040  int i;
3041 
3042  assert(scip != NULL);
3043  assert(scip->set != NULL);
3044 
3045  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintCutselectorStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3046 
3047  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Cutselectors : ExecTime SetupTime Calls RootCalls Selected Forced Filtered RootSelec RootForc RootFilt \n");
3048 
3049  /* sort cutsels w.r.t. their priority */
3050  SCIPsetSortCutsels(scip->set);
3051 
3052  for( i = 0; i < scip->set->ncutsels; ++i )
3053  {
3054  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",
3055  SCIPcutselGetName(scip->set->cutsels[i]),
3056  SCIPcutselGetTime(scip->set->cutsels[i]),
3057  SCIPcutselGetSetupTime(scip->set->cutsels[i]),
3058  SCIPcutselGetNCalls(scip->set->cutsels[i]),
3059  SCIPcutselGetNRootCalls(scip->set->cutsels[i]),
3063  SCIPcutselGetNRootCuts(scip->set->cutsels[i]),
3066  );
3067  }
3068 }
3069 
3070 /** outputs pricer statistics
3071  *
3072  * @pre This method can be called if SCIP is in one of the following stages:
3073  * - \ref SCIP_STAGE_SOLVING
3074  * - \ref SCIP_STAGE_SOLVED
3075  */
3077  SCIP* scip, /**< SCIP data structure */
3078  FILE* file /**< output file */
3079  )
3080 {
3081  int i;
3082 
3083  assert(scip != NULL);
3084  assert(scip->set != NULL);
3085 
3086  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintPricerStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3087 
3088  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Pricers : ExecTime SetupTime Calls Vars\n");
3089  SCIPmessageFPrintInfo(scip->messagehdlr, file, " problem variables: %10.2f - %10d %10d\n",
3093 
3094  /* sort pricers w.r.t. their name */
3095  SCIPsetSortPricersName(scip->set);
3096 
3097  for( i = 0; i < scip->set->nactivepricers; ++i )
3098  {
3099  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s: %10.2f %10.2f %10d %10d\n",
3100  SCIPpricerGetName(scip->set->pricers[i]),
3101  SCIPpricerGetTime(scip->set->pricers[i]),
3102  SCIPpricerGetSetupTime(scip->set->pricers[i]),
3103  SCIPpricerGetNCalls(scip->set->pricers[i]),
3104  SCIPpricerGetNVarsFound(scip->set->pricers[i]));
3105  }
3106 }
3107 
3108 /** outputs branching rule statistics
3109  *
3110  * @pre This method can be called if SCIP is in one of the following stages:
3111  * - \ref SCIP_STAGE_SOLVING
3112  * - \ref SCIP_STAGE_SOLVED
3113  */
3115  SCIP* scip, /**< SCIP data structure */
3116  FILE* file /**< output file */
3117  )
3118 {
3119  int i;
3120 
3121  assert(scip != NULL);
3122  assert(scip->set != NULL);
3123 
3124  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintBranchruleStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3125 
3126  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Branching Rules : ExecTime SetupTime BranchLP BranchExt BranchPS Cutoffs DomReds Cuts Conss Children\n");
3127 
3128  /* sort branching rules w.r.t. their name */
3130 
3131  for( i = 0; i < scip->set->nbranchrules; ++i )
3132  {
3133  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",
3145  }
3146 }
3147 
3148 /** outputs heuristics statistics
3149  *
3150  * @pre This method can be called if SCIP is in one of the following stages:
3151  * - \ref SCIP_STAGE_PRESOLVING
3152  * - \ref SCIP_STAGE_EXITPRESOLVE
3153  * - \ref SCIP_STAGE_PRESOLVED
3154  * - \ref SCIP_STAGE_SOLVING
3155  * - \ref SCIP_STAGE_SOLVED
3156  */
3158  SCIP* scip, /**< SCIP data structure */
3159  FILE* file /**< output file */
3160  )
3161 {
3162  int ndivesets = 0;
3163  int i;
3164 
3165  assert(scip != NULL);
3166  assert(scip->set != NULL);
3167  assert(scip->tree != NULL);
3168 
3169  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintHeuristicStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3170 
3171  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Primal Heuristics : ExecTime SetupTime Calls Found Best\n");
3172  SCIPmessageFPrintInfo(scip->messagehdlr, file, " LP solutions : %10.2f - - %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT "\n",
3174  scip->stat->nlpsolsfound, scip->stat->nlpbestsolsfound);
3175  SCIPmessageFPrintInfo(scip->messagehdlr, file, " relax solutions : %10.2f - - %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT "\n",
3177  scip->stat->nrelaxsolsfound, scip->stat->nrelaxbestsolsfound);
3178  SCIPmessageFPrintInfo(scip->messagehdlr, file, " pseudo solutions : %10.2f - - %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT "\n",
3180  scip->stat->npssolsfound, scip->stat->npsbestsolsfound);
3181  SCIPmessageFPrintInfo(scip->messagehdlr, file, " strong branching : %10.2f - - %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT "\n",
3183  scip->stat->nsbsolsfound, scip->stat->nsbbestsolsfound);
3184 
3185  /* sort heuristics w.r.t. their names */
3186  SCIPsetSortHeursName(scip->set);
3187 
3188  for( i = 0; i < scip->set->nheurs; ++i )
3189  {
3190  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s: %10.2f %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT "\n",
3191  SCIPheurGetName(scip->set->heurs[i]),
3192  SCIPheurGetTime(scip->set->heurs[i]),
3193  SCIPheurGetSetupTime(scip->set->heurs[i]),
3194  SCIPheurGetNCalls(scip->set->heurs[i]),
3195  SCIPheurGetNSolsFound(scip->set->heurs[i]),
3196  SCIPheurGetNBestSolsFound(scip->set->heurs[i]));
3197 
3198  /* count heuristics that use diving; needed to determine output later */
3199  ndivesets += SCIPheurGetNDivesets(scip->set->heurs[i]);
3200  }
3201 
3202  SCIPmessageFPrintInfo(scip->messagehdlr, file, " other solutions : - - - %10" SCIP_LONGINT_FORMAT " -\n",
3203  scip->stat->nexternalsolsfound);
3204 
3205  if ( ndivesets > 0 && scip->set->misc_showdivingstats )
3206  {
3207  int c;
3209 
3210  /* print statistics for both contexts individually */
3211  for( c = 0; c < 2; ++c )
3212  {
3213  SCIP_DIVECONTEXT divecontext = divecontexts[c];
3214  SCIPmessageFPrintInfo(scip->messagehdlr, file,
3215  "Diving %-12s: Calls Nodes LP Iters Backtracks Conflicts MinDepth MaxDepth AvgDepth RoundSols NLeafSols MinSolDpt MaxSolDpt AvgSolDpt\n",
3216  divecontext == SCIP_DIVECONTEXT_SINGLE ? "(single)" : "(adaptive)");
3217 
3218  for( i = 0; i < scip->set->nheurs; ++i )
3219  {
3220  int s;
3221  for( s = 0; s < SCIPheurGetNDivesets(scip->set->heurs[i]); ++s )
3222  {
3223  SCIP_DIVESET* diveset = SCIPheurGetDivesets(scip->set->heurs[i])[s];
3224 
3225  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s: %10d",
3226  SCIPdivesetGetName(diveset),
3227  SCIPdivesetGetNCalls(diveset, divecontext));
3228  if( SCIPdivesetGetNCalls(diveset, divecontext) > 0 )
3229  {
3230  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,
3231  SCIPdivesetGetNProbingNodes(diveset, divecontext),
3232  SCIPdivesetGetNLPIterations(diveset, divecontext),
3233  SCIPdivesetGetNBacktracks(diveset, divecontext),
3234  SCIPdivesetGetNConflicts(diveset, divecontext),
3235  SCIPdivesetGetMinDepth(diveset, divecontext),
3236  SCIPdivesetGetMaxDepth(diveset, divecontext),
3237  SCIPdivesetGetAvgDepth(diveset, divecontext),
3238  SCIPdivesetGetNSols(diveset, divecontext) - SCIPdivesetGetNSolutionCalls(diveset, divecontext));
3239 
3240  if( SCIPdivesetGetNSolutionCalls(diveset, divecontext) > 0 )
3241  {
3242  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10d %10d %10d %10.1f\n",
3243  SCIPdivesetGetNSolutionCalls(diveset, divecontext),
3244  SCIPdivesetGetMinSolutionDepth(diveset, divecontext),
3245  SCIPdivesetGetMaxSolutionDepth(diveset, divecontext),
3246  SCIPdivesetGetAvgSolutionDepth(diveset, divecontext));
3247  }
3248  else
3249  SCIPmessageFPrintInfo(scip->messagehdlr, file, " - - - -\n");
3250  }
3251  else
3252  SCIPmessageFPrintInfo(scip->messagehdlr, file, " - - - - - - - - - - - -\n");
3253  }
3254  }
3255  }
3256  }
3257 }
3258 
3259 /** outputs compression statistics
3260  *
3261  * @pre This method can be called if SCIP is in one of the following stages:
3262  * - \ref SCIP_STAGE_PRESOLVING
3263  * - \ref SCIP_STAGE_EXITPRESOLVE
3264  * - \ref SCIP_STAGE_PRESOLVED
3265  * - \ref SCIP_STAGE_SOLVING
3266  * - \ref SCIP_STAGE_SOLVED
3267  */
3269  SCIP* scip, /**< SCIP data structure */
3270  FILE* file /**< output file */
3271  )
3272 {
3273  int i;
3274 
3275  assert(scip != NULL);
3276 
3277  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintCompressionStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3278 
3279  /* only print compression statistics if tree reoptimization is enabled */
3280  if( !scip->set->reopt_enable )
3281  return;
3282 
3283  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Tree Compressions : ExecTime SetupTime Calls Found\n");
3284 
3285  /* sort compressions w.r.t. their names */
3286  SCIPsetSortComprsName(scip->set);
3287 
3288  for( i = 0; i < scip->set->ncomprs; ++i )
3289  {
3290  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s: %10.2f %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT "\n",
3291  SCIPcomprGetName(scip->set->comprs[i]),
3292  SCIPcomprGetTime(scip->set->comprs[i]),
3293  SCIPcomprGetSetupTime(scip->set->comprs[i]),
3294  SCIPcomprGetNCalls(scip->set->comprs[i]),
3295  SCIPcomprGetNFound(scip->set->comprs[i]));
3296  }
3297 }
3298 
3299 /** outputs LP statistics
3300  *
3301  * @pre This method can be called if SCIP is in one of the following stages:
3302  * - \ref SCIP_STAGE_SOLVING
3303  * - \ref SCIP_STAGE_SOLVED
3304  */
3306  SCIP* scip, /**< SCIP data structure */
3307  FILE* file /**< output file */
3308  )
3309 {
3310  assert(scip != NULL);
3311  assert(scip->stat != NULL);
3312  assert(scip->lp != NULL);
3313 
3314  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintLPStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3315 
3316  SCIPmessageFPrintInfo(scip->messagehdlr, file, "LP : Time Calls Iterations Iter/call Iter/sec Time-0-It Calls-0-It ItLimit\n");
3317 
3318  SCIPmessageFPrintInfo(scip->messagehdlr, file, " primal LP : %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.2f",
3320  scip->stat->nprimallps + scip->stat->nprimalzeroitlps,
3321  scip->stat->nprimallpiterations,
3322  scip->stat->nprimallps > 0 ? (SCIP_Real)scip->stat->nprimallpiterations/(SCIP_Real)scip->stat->nprimallps : 0.0);
3323  if( SCIPclockGetTime(scip->stat->primallptime) >= 0.01 )
3325  else
3326  SCIPmessageFPrintInfo(scip->messagehdlr, file, " -");
3327  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f %10" SCIP_LONGINT_FORMAT "\n",
3328  scip->stat->primalzeroittime,
3329  scip->stat->nprimalzeroitlps);
3330 
3331  SCIPmessageFPrintInfo(scip->messagehdlr, file, " dual LP : %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.2f",
3333  scip->stat->nduallps + scip->stat->ndualzeroitlps,
3334  scip->stat->nduallpiterations,
3335  scip->stat->nduallps > 0 ? (SCIP_Real)scip->stat->nduallpiterations/(SCIP_Real)scip->stat->nduallps : 0.0);
3336  if( SCIPclockGetTime(scip->stat->duallptime) >= 0.01 )
3338  else
3339  SCIPmessageFPrintInfo(scip->messagehdlr, file, " -");
3340  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f %10" SCIP_LONGINT_FORMAT "\n",
3341  scip->stat->dualzeroittime,
3342  scip->stat->ndualzeroitlps);
3343 
3344  SCIPmessageFPrintInfo(scip->messagehdlr, file, " lex dual LP : %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.2f",
3346  scip->stat->nlexduallps,
3347  scip->stat->nlexduallpiterations,
3348  scip->stat->nlexduallps > 0 ? (SCIP_Real)scip->stat->nlexduallpiterations/(SCIP_Real)scip->stat->nlexduallps : 0.0);
3349  if( SCIPclockGetTime(scip->stat->lexduallptime) >= 0.01 )
3351  else
3352  SCIPmessageFPrintInfo(scip->messagehdlr, file, " -\n");
3353 
3354  SCIPmessageFPrintInfo(scip->messagehdlr, file, " barrier LP : %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.2f",
3356  scip->stat->nbarrierlps,
3357  scip->stat->nbarrierlpiterations,
3358  scip->stat->nbarrierlps > 0 ? (SCIP_Real)scip->stat->nbarrierlpiterations/(SCIP_Real)scip->stat->nbarrierlps : 0.0);
3359  if( SCIPclockGetTime(scip->stat->barrierlptime) >= 0.01 )
3361  else
3362  SCIPmessageFPrintInfo(scip->messagehdlr, file, " -");
3363  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f %10" SCIP_LONGINT_FORMAT "\n",
3364  scip->stat->barrierzeroittime,
3365  scip->stat->nbarrierzeroitlps);
3366 
3367  SCIPmessageFPrintInfo(scip->messagehdlr, file, " resolve instable : %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.2f",
3369  scip->stat->nresolveinstablelps,
3372  if( SCIPclockGetTime(scip->stat->resolveinstablelptime) >= 0.01 )
3374  else
3375  SCIPmessageFPrintInfo(scip->messagehdlr, file, " -\n");
3376 
3377  SCIPmessageFPrintInfo(scip->messagehdlr, file, " diving/probing LP: %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.2f",
3379  scip->stat->ndivinglps,
3380  scip->stat->ndivinglpiterations,
3381  scip->stat->ndivinglps > 0 ? (SCIP_Real)scip->stat->ndivinglpiterations/(SCIP_Real)scip->stat->ndivinglps : 0.0);
3382  if( SCIPclockGetTime(scip->stat->divinglptime) >= 0.01 )
3384  else
3385  SCIPmessageFPrintInfo(scip->messagehdlr, file, " -\n");
3386 
3387  SCIPmessageFPrintInfo(scip->messagehdlr, file, " strong branching : %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.2f",
3389  scip->stat->nstrongbranchs,
3390  scip->stat->nsblpiterations,
3391  scip->stat->nstrongbranchs > 0 ? (SCIP_Real)scip->stat->nsblpiterations/(SCIP_Real)scip->stat->nstrongbranchs : 0.0);
3392  if( SCIPclockGetTime(scip->stat->strongbranchtime) >= 0.01 )
3394  else
3395  SCIPmessageFPrintInfo(scip->messagehdlr, file, " -");
3396  SCIPmessageFPrintInfo(scip->messagehdlr, file, " - - %10" SCIP_LONGINT_FORMAT "\n", scip->stat->nsbtimesiterlimhit);
3397 
3398  SCIPmessageFPrintInfo(scip->messagehdlr, file, " (at root node) : - %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.2f -\n",
3399  scip->stat->nrootstrongbranchs,
3400  scip->stat->nrootsblpiterations,
3401  scip->stat->nrootstrongbranchs > 0
3403 
3404  SCIPmessageFPrintInfo(scip->messagehdlr, file, " conflict analysis: %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.2f",
3406  scip->stat->nconflictlps,
3407  scip->stat->nconflictlpiterations,
3408  scip->stat->nconflictlps > 0 ? (SCIP_Real)scip->stat->nconflictlpiterations/(SCIP_Real)scip->stat->nconflictlps : 0.0);
3409  if( SCIPclockGetTime(scip->stat->conflictlptime) >= 0.01 )
3411  else
3412  SCIPmessageFPrintInfo(scip->messagehdlr, file, " -\n");
3413 }
3414 
3415 /** outputs NLP statistics
3416  *
3417  * @pre This method can be called if SCIP is in one of the following stages:
3418  * - \ref SCIP_STAGE_SOLVING
3419  * - \ref SCIP_STAGE_SOLVED
3420  */
3422  SCIP* scip, /**< SCIP data structure */
3423  FILE* file /**< output file */
3424  )
3425 {
3426  assert(scip != NULL);
3427  assert(scip->stat != NULL);
3428 
3429  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintNLPStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3430 
3431  if( scip->nlp == NULL )
3432  return;
3433 
3434  SCIPmessageFPrintInfo(scip->messagehdlr, file, "NLP : Time Calls\n");
3435 
3436  SCIPmessageFPrintInfo(scip->messagehdlr, file, " all NLPs : %10.2f %10" SCIP_LONGINT_FORMAT "\n",
3438  scip->stat->nnlps);
3439 }
3440 
3441 /** outputs relaxator statistics
3442  *
3443  * @pre This method can be called if SCIP is in one of the following stages:
3444  * - \ref SCIP_STAGE_SOLVING
3445  * - \ref SCIP_STAGE_SOLVED
3446  */
3448  SCIP* scip, /**< SCIP data structure */
3449  FILE* file /**< output file */
3450  )
3451 {
3452  int i;
3453 
3454  assert(scip != NULL);
3455  assert(scip->set != NULL);
3456 
3457  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintRelaxatorStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3458 
3459  if( scip->set->nrelaxs == 0 )
3460  return;
3461 
3462  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Relaxators : Time Calls Cutoffs ImprBounds ImprTime ReducedDom Separated AddedConss\n");
3463 
3464  /* sort relaxators w.r.t. their name */
3465  SCIPsetSortRelaxsName(scip->set);
3466 
3467  for( i = 0; i < scip->set->nrelaxs; ++i )
3468  {
3469  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",
3470  SCIPrelaxGetName(scip->set->relaxs[i]),
3471  SCIPrelaxGetTime(scip->set->relaxs[i]),
3472  SCIPrelaxGetNCalls(scip->set->relaxs[i]),
3473  SCIPrelaxGetNCutoffs(scip->set->relaxs[i]),
3479  );
3480  }
3481 }
3482 
3483 /** outputs tree statistics
3484  *
3485  * @pre This method can be called if SCIP is in one of the following stages:
3486  * - \ref SCIP_STAGE_SOLVING
3487  * - \ref SCIP_STAGE_SOLVED
3488  */
3490  SCIP* scip, /**< SCIP data structure */
3491  FILE* file /**< output file */
3492  )
3493 {
3494  assert(scip != NULL);
3495  assert(scip->stat != NULL);
3496  assert(scip->tree != NULL);
3497 
3498  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintTreeStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3499 
3500  SCIPmessageFPrintInfo(scip->messagehdlr, file, "B&B Tree :\n");
3501  SCIPmessageFPrintInfo(scip->messagehdlr, file, " number of runs : %10d\n", scip->stat->nruns);
3502  SCIPmessageFPrintInfo(scip->messagehdlr, file,
3503  " nodes : %10" SCIP_LONGINT_FORMAT " (%" SCIP_LONGINT_FORMAT " internal, %" SCIP_LONGINT_FORMAT " leaves)\n",
3504  scip->stat->nnodes, scip->stat->ninternalnodes, scip->stat->nnodes - scip->stat->ninternalnodes );
3505  SCIPmessageFPrintInfo(scip->messagehdlr, file, " feasible leaves : %10" SCIP_LONGINT_FORMAT "\n", scip->stat->nfeasleaves);
3506  SCIPmessageFPrintInfo(scip->messagehdlr, file, " infeas. leaves : %10" SCIP_LONGINT_FORMAT "\n", scip->stat->ninfeasleaves);
3507  SCIPmessageFPrintInfo(scip->messagehdlr, file, " objective leaves : %10" SCIP_LONGINT_FORMAT "\n", scip->stat->nobjleaves);
3508  SCIPmessageFPrintInfo(scip->messagehdlr, file,
3509  " nodes (total) : %10" SCIP_LONGINT_FORMAT " (%" SCIP_LONGINT_FORMAT " internal, %" SCIP_LONGINT_FORMAT " leaves)\n",
3511  SCIPmessageFPrintInfo(scip->messagehdlr, file, " nodes left : %10d\n", SCIPtreeGetNNodes(scip->tree));
3512  SCIPmessageFPrintInfo(scip->messagehdlr, file, " max depth : %10d\n", scip->stat->maxdepth);
3513  SCIPmessageFPrintInfo(scip->messagehdlr, file, " max depth (total): %10d\n", scip->stat->maxtotaldepth);
3514  SCIPmessageFPrintInfo(scip->messagehdlr, file, " backtracks : %10" SCIP_LONGINT_FORMAT " (%.1f%%)\n", scip->stat->nbacktracks,
3515  scip->stat->nnodes > 0 ? 100.0 * (SCIP_Real)scip->stat->nbacktracks / (SCIP_Real)scip->stat->nnodes : 0.0);
3516  SCIPmessageFPrintInfo(scip->messagehdlr, file, " early backtracks : %10" SCIP_LONGINT_FORMAT " (%.1f%%)\n", scip->stat->nearlybacktracks,
3517  scip->stat->nbacktracks > 0 ? 100.0 * (SCIP_Real)scip->stat->nearlybacktracks / (SCIP_Real)scip->stat->nbacktracks : 0.0);
3518  SCIPmessageFPrintInfo(scip->messagehdlr, file, " nodes exc. ref. : %10" SCIP_LONGINT_FORMAT " (%.1f%%)\n", scip->stat->nnodesaboverefbound,
3519  scip->stat->nnodes > 0 ? 100.0 * (SCIP_Real)scip->stat->nnodesaboverefbound / (SCIP_Real)scip->stat->nnodes : 0.0);
3520 
3521  SCIPmessageFPrintInfo(scip->messagehdlr, file, " delayed cutoffs : %10" SCIP_LONGINT_FORMAT "\n", scip->stat->ndelayedcutoffs);
3522  SCIPmessageFPrintInfo(scip->messagehdlr, file, " repropagations : %10" SCIP_LONGINT_FORMAT " (%" SCIP_LONGINT_FORMAT " domain reductions, %" SCIP_LONGINT_FORMAT " cutoffs)\n",
3523  scip->stat->nreprops, scip->stat->nrepropboundchgs, scip->stat->nrepropcutoffs);
3524  SCIPmessageFPrintInfo(scip->messagehdlr, file, " avg switch length: %10.2f\n",
3525  scip->stat->nnodes > 0
3526  ? (SCIP_Real)(scip->stat->nactivatednodes + scip->stat->ndeactivatednodes) / (SCIP_Real)scip->stat->nnodes : 0.0);
3527  SCIPmessageFPrintInfo(scip->messagehdlr, file, " switching time : %10.2f\n", SCIPclockGetTime(scip->stat->nodeactivationtime));
3528 }
3529 
3530 /** outputs solution statistics
3531  *
3532  * @pre This method can be called if SCIP is in one of the following stages:
3533  * - \ref SCIP_STAGE_PRESOLVING
3534  * - \ref SCIP_STAGE_EXITPRESOLVE
3535  * - \ref SCIP_STAGE_PRESOLVED
3536  * - \ref SCIP_STAGE_SOLVING
3537  * - \ref SCIP_STAGE_SOLVED
3538  */
3540  SCIP* scip, /**< SCIP data structure */
3541  FILE* file /**< output file */
3542  )
3543 {
3544  SCIP_Real primalbound;
3545  SCIP_Real dualbound;
3546  SCIP_Real gap;
3547  SCIP_Real firstprimalbound;
3548  SCIP_Bool objlimitreached;
3549  char limsolstring[SCIP_MAXSTRLEN];
3550 
3551  assert(scip != NULL);
3552  assert(scip->stat != NULL);
3553  assert(scip->primal != NULL);
3554 
3555  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintSolutionStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3556 
3557  primalbound = SCIPgetPrimalbound(scip);
3558  dualbound = SCIPgetDualbound(scip);
3559  gap = SCIPgetGap(scip);
3560 
3561  /* We output that the objective limit has been reached if the problem has been solved, no solution respecting the
3562  * objective limit has been found (nlimsolsfound == 0) and the primal bound is finite. Note that it still might be
3563  * that the original problem is infeasible, even without the objective limit, i.e., we cannot be sure that we
3564  * actually reached the objective limit. */
3565  objlimitreached = FALSE;
3566  if( SCIPgetStage(scip) == SCIP_STAGE_SOLVED && scip->primal->nlimsolsfound == 0
3567  && !SCIPisInfinity(scip, primalbound) && SCIPgetStatus(scip) != SCIP_STATUS_INFORUNBD )
3568  objlimitreached = TRUE;
3569 
3570  if( scip->primal->nsolsfound != scip->primal->nlimsolsfound )
3571  (void) SCIPsnprintf(limsolstring, SCIP_MAXSTRLEN, ", %" SCIP_LONGINT_FORMAT " respecting the objective limit", scip->primal->nlimsolsfound);
3572  else
3573  limsolstring[0] = '\0';
3574 
3575  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Solution :\n");
3576  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Solutions found : %10" SCIP_LONGINT_FORMAT " (%" SCIP_LONGINT_FORMAT " improvements%s)\n",
3577  scip->primal->nsolsfound, scip->primal->nbestsolsfound, limsolstring);
3578 
3579  if( SCIPsetIsInfinity(scip->set, REALABS(primalbound)) )
3580  {
3581  if( scip->set->stage == SCIP_STAGE_SOLVED )
3582  {
3583  if( scip->primal->nlimsolsfound == 0 )
3584  {
3585  if( SCIPgetStatus(scip) == SCIP_STATUS_INFORUNBD )
3586  {
3587  assert(!objlimitreached);
3588  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Primal Bound : infeasible or unbounded\n");
3589  }
3590  else
3591  {
3592  assert(SCIPgetStatus(scip) == SCIP_STATUS_INFEASIBLE);
3593  if( objlimitreached )
3594  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Primal Bound : infeasible (objective limit reached)\n");
3595  else
3596  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Primal Bound : infeasible\n");
3597  }
3598  }
3599  else
3600  {
3601  assert(!objlimitreached);
3602  assert(SCIPgetStatus(scip) == SCIP_STATUS_UNBOUNDED);
3603  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Primal Bound : unbounded\n");
3604  }
3605  }
3606  else
3607  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Primal Bound : -\n");
3608  }
3609  else
3610  {
3611  if( scip->primal->nlimsolsfound == 0 )
3612  {
3613  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Primal Bound : %+21.14e (objective limit)\n", primalbound);
3614 
3615  /* display (best) primal bound */
3616  if( scip->primal->nsolsfound > 0 )
3617  {
3618  SCIP_Real bestsol;
3619  bestsol = SCIPsolGetObj(scip->primal->sols[0], scip->set, scip->transprob, scip->origprob);
3620  bestsol = SCIPretransformObj(scip, bestsol);
3621 
3622  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Best Solution : %+21.14e\n", bestsol);
3623  }
3624  }
3625  else
3626  {
3627  /* display first primal bound line */
3628  firstprimalbound = scip->stat->firstprimalbound;
3629  SCIPmessageFPrintInfo(scip->messagehdlr, file, " First Solution : %+21.14e", firstprimalbound);
3630 
3631  SCIPmessageFPrintInfo(scip->messagehdlr, file, " (in run %d, after %" SCIP_LONGINT_FORMAT " nodes, %.2f seconds, depth %d, found by <%s>)\n",
3632  scip->stat->nrunsbeforefirst,
3633  scip->stat->nnodesbeforefirst,
3634  scip->stat->firstprimaltime,
3635  scip->stat->firstprimaldepth,
3636  ( scip->stat->firstprimalheur != NULL )
3637  ? ( SCIPheurGetName(scip->stat->firstprimalheur) )
3638  : (( scip->stat->nrunsbeforefirst == 0 ) ? "initial" : "relaxation"));
3639 
3640  if( SCIPisInfinity(scip, scip->stat->firstsolgap) )
3641  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Gap First Sol. : infinite\n");
3642  else
3643  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Gap First Sol. : %10.2f %%\n", 100.0 * scip->stat->firstsolgap);
3644 
3645  if( SCIPisInfinity(scip, scip->stat->lastsolgap) )
3646  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Gap Last Sol. : infinite\n");
3647  else
3648  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Gap Last Sol. : %10.2f %%\n", 100.0 * scip->stat->lastsolgap);
3649 
3650  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Primal Bound : %+21.14e", primalbound);
3651 
3652  SCIPmessageFPrintInfo(scip->messagehdlr, file, " (in run %d, after %" SCIP_LONGINT_FORMAT " nodes, %.2f seconds, depth %d, found by <%s>)\n",
3653  SCIPsolGetRunnum(scip->primal->sols[0]),
3654  SCIPsolGetNodenum(scip->primal->sols[0]),
3655  SCIPsolGetTime(scip->primal->sols[0]),
3656  SCIPsolGetDepth(scip->primal->sols[0]),
3657  SCIPsolGetHeur(scip->primal->sols[0]) != NULL
3659  : (SCIPsolGetRunnum(scip->primal->sols[0]) == 0 ? "initial" : "relaxation"));
3660  }
3661  }
3662 
3663  if( SCIPsetIsInfinity(scip->set, REALABS(dualbound)) )
3664  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Dual Bound : -\n");
3665  else
3666  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Dual Bound : %+21.14e\n", dualbound);
3667 
3668  if( SCIPsetIsInfinity(scip->set, gap) )
3669  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Gap : infinite\n");
3670  else
3671  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Gap : %10.2f %%\n", 100.0 * gap);
3672 
3673  if( scip->set->misc_calcintegral )
3674  {
3675  int s;
3676  const char* names[] = {
3677  "primal-dual",
3678  "primal-ref",
3679  "dual-ref"
3680  };
3681  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Integrals : Total Avg%%\n");
3682  if( SCIPgetStatus(scip) == SCIP_STATUS_INFEASIBLE && ! objlimitreached )
3683  {
3684  for( s = 0; s < 3; ++s )
3685  {
3686  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17s: %10s %10s (problem infeasible)\n",
3687  names[s], "-", "-");
3688  }
3689  }
3690  else
3691  {
3692  SCIP_Real integrals[3];
3693  SCIP_Real solvingtime = SCIPgetSolvingTime(scip);
3694 
3695  if( !SCIPisFeasZero(scip, solvingtime) )
3696  {
3697  integrals[0] = SCIPstatGetPrimalDualIntegral(scip->stat, scip->set, scip->transprob, scip->origprob, TRUE);
3698 
3699  if( scip->set->misc_referencevalue != SCIP_INVALID ) /*lint !e777*/
3700  {
3701  integrals[1] = SCIPstatGetPrimalReferenceIntegral(scip->stat, scip->set, scip->transprob, scip->origprob, FALSE);
3702  integrals[2] = SCIPstatGetDualReferenceIntegral(scip->stat, scip->set, scip->transprob, scip->origprob, FALSE);
3703  }
3704  else
3705  integrals[1] = integrals[2] = SCIP_INVALID;
3706  }
3707  else
3708  {
3709  BMSclearMemoryArray(integrals, 3);
3710  }
3711 
3712  /* print integrals, if computed */
3713  for( s = 0; s < 3; ++s )
3714  {
3715  if( integrals[s] == SCIP_INVALID ) /*lint !e777*/
3716  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17s: - - (not evaluated)\n", names[s]);
3717  else
3718  {
3719  SCIP_Real avg = integrals[s] / MAX(solvingtime,1e-6);
3720 
3721  /* caution: this assert is non-deterministic since it depends on the solving time */
3722  assert(0.0 <= avg && SCIPisLE(scip, avg, 100.0));
3723  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17s: %10.2f %10.2f\n", names[s], integrals[s], avg);
3724  }
3725  }
3726  }
3727  }
3728 }
3729 
3730 /** outputs concurrent solver statistics
3731  *
3732  * @pre This method can be called if SCIP is in one of the following stages:
3733  * - \ref SCIP_STAGE_TRANSFORMED
3734  * - \ref SCIP_STAGE_INITPRESOLVE
3735  * - \ref SCIP_STAGE_PRESOLVING
3736  * - \ref SCIP_STAGE_EXITPRESOLVE
3737  * - \ref SCIP_STAGE_PRESOLVED
3738  * - \ref SCIP_STAGE_SOLVING
3739  * - \ref SCIP_STAGE_SOLVED
3740  */
3742  SCIP* scip, /**< SCIP data structure */
3743  FILE* file /**< output file */
3744  )
3745 {
3746  SCIP_CONCSOLVER** concsolvers;
3747  int nconcsolvers;
3748  int i;
3749  int winner;
3750 
3751  assert(scip != NULL);
3752  assert(scip->set != NULL);
3753 
3754  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintConcsolverStatistics", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3755 
3757  return;
3758 
3759  nconcsolvers = SCIPgetNConcurrentSolvers(scip);
3760  concsolvers = SCIPgetConcurrentSolvers(scip);
3761  winner = SCIPsyncstoreGetWinner(scip->syncstore);
3762 
3763  if( nconcsolvers > 0 )
3764  {
3765  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Concurrent Solvers : SolvingTime SyncTime Nodes LP Iters SolsShared SolsRecvd TighterBnds TighterIntBnds\n");
3766  for( i = 0; i < nconcsolvers; ++i )
3767  {
3768  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %c%-16s: %11.2f %11.2f %11" SCIP_LONGINT_FORMAT " %11" SCIP_LONGINT_FORMAT "%11" SCIP_LONGINT_FORMAT " %11" SCIP_LONGINT_FORMAT " %11" SCIP_LONGINT_FORMAT " %14" SCIP_LONGINT_FORMAT "\n",
3769  winner == i ? '*' : ' ',
3770  SCIPconcsolverGetName(concsolvers[i]),
3771  SCIPconcsolverGetSolvingTime(concsolvers[i]),
3772  SCIPconcsolverGetSyncTime(concsolvers[i]),
3773  SCIPconcsolverGetNNodes(concsolvers[i]),
3774  SCIPconcsolverGetNLPIterations(concsolvers[i]),
3775  SCIPconcsolverGetNSolsShared(concsolvers[i]),
3776  SCIPconcsolverGetNSolsRecvd(concsolvers[i]),
3777  SCIPconcsolverGetNTighterBnds(concsolvers[i]),
3778  SCIPconcsolverGetNTighterIntBnds(concsolvers[i])
3779  );
3780  }
3781  }
3782 }
3783 
3784 /** display Benders' decomposition statistics */
3786  SCIP* scip, /**< SCIP data structure */
3787  FILE* file /**< output file */
3788  )
3789 {
3790  SCIP_BENDERS** benders;
3791  int nbenders;
3792  int i;
3793 
3794  assert(scip != NULL);
3795  assert(scip->set != NULL);
3796 
3797  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintBendersStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3798 
3799  if( SCIPgetNActiveBenders(scip) == 0 )
3800  return;
3801 
3802  nbenders = SCIPgetNBenders(scip);
3803  benders = SCIPgetBenders(scip);
3804 
3805  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Benders Decomp : ExecTime SetupTime Calls Found Transfer StrCalls StrFails StrCuts\n");
3806  for( i = 0; i < nbenders; ++i )
3807  {
3808  if( SCIPbendersIsActive(benders[i]) )
3809  {
3810  SCIP_BENDERSCUT** benderscuts;
3811  int nbenderscuts;
3812  int j;
3813 
3814  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s: %10.2f %10.2f %10d %10d %10d %10d %10d %10d\n",
3815  SCIPbendersGetName(scip->set->benders[i]),
3816  SCIPbendersGetTime(scip->set->benders[i]),
3817  SCIPbendersGetSetupTime(scip->set->benders[i]),
3818  SCIPbendersGetNCalls(scip->set->benders[i]),
3824 
3825  nbenderscuts = SCIPbendersGetNBenderscuts(scip->set->benders[i]);
3826  benderscuts = SCIPbendersGetBenderscuts(scip->set->benders[i]);
3827 
3828  for( j = 0; j < nbenderscuts; j++ )
3829  {
3830  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-15.17s: %10.2f %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " -\n",
3831  SCIPbenderscutGetName(benderscuts[j]),
3832  SCIPbenderscutGetTime(benderscuts[j]),
3833  SCIPbenderscutGetSetupTime(benderscuts[j]),
3834  SCIPbenderscutGetNCalls(benderscuts[j]),
3835  SCIPbenderscutGetNFound(benderscuts[j]));
3836  }
3837  }
3838  }
3839 }
3840 
3841 /** outputs root statistics
3842  *
3843  * @pre This method can be called if SCIP is in one of the following stages:
3844  * - \ref SCIP_STAGE_SOLVING
3845  * - \ref SCIP_STAGE_SOLVED
3846  */
3848  SCIP* scip, /**< SCIP data structure */
3849  FILE* file /**< output file */
3850  )
3851 {
3852  SCIP_Real dualboundroot;
3853  SCIP_Real firstdualboundroot;
3854  SCIP_Real firstlptime;
3855  SCIP_Real firstlpspeed;
3856 
3857  assert(scip != NULL);
3858  assert(scip->stat != NULL);
3859  assert(scip->primal != NULL);
3860 
3861  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintRootStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3862 
3863  dualboundroot = SCIPgetDualboundRoot(scip);
3864  firstdualboundroot = SCIPgetFirstLPDualboundRoot(scip);
3865  firstlptime = SCIPgetFirstLPTime(scip);
3866 
3867  if( firstlptime > 0.0 )
3868  firstlpspeed = (SCIP_Real)scip->stat->nrootfirstlpiterations/firstlptime;
3869  else
3870  firstlpspeed = 0.0;
3871 
3872  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Root Node :\n");
3873  if( SCIPsetIsInfinity(scip->set, REALABS(firstdualboundroot)) )
3874  SCIPmessageFPrintInfo(scip->messagehdlr, file, " First LP value : -\n");
3875  else
3876  SCIPmessageFPrintInfo(scip->messagehdlr, file, " First LP value : %+21.14e\n", firstdualboundroot);
3877  if( firstlpspeed > 0.0 )
3878  SCIPmessageFPrintInfo(scip->messagehdlr, file, " First LP Iters : %10" SCIP_LONGINT_FORMAT " (%.2f Iter/sec)\n",
3880  (SCIP_Real)scip->stat->nrootfirstlpiterations/firstlptime);
3881  else
3882  SCIPmessageFPrintInfo(scip->messagehdlr, file, " First LP Iters : %10" SCIP_LONGINT_FORMAT "\n", scip->stat->nrootfirstlpiterations);
3883  SCIPmessageFPrintInfo(scip->messagehdlr, file, " First LP Time : %10.2f\n", firstlptime);
3884 
3885  if( SCIPsetIsInfinity(scip->set, REALABS(dualboundroot)) )
3886  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Final Dual Bound : -\n");
3887  else
3888  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Final Dual Bound : %+21.14e\n", dualboundroot);
3889  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Final Root Iters : %10" SCIP_LONGINT_FORMAT "\n", scip->stat->nrootlpiterations);
3890 
3891  SCIPmessageFPrintInfo(scip->messagehdlr, file, " Root LP Estimate : ");
3892  if( scip->stat->rootlpbestestimate != SCIP_INVALID ) /*lint !e777*/
3893  {
3894  SCIPmessageFPrintInfo(scip->messagehdlr, file, "%+21.14e\n", SCIPretransformObj(scip, scip->stat->rootlpbestestimate));
3895  }
3896  else
3897  SCIPmessageFPrintInfo(scip->messagehdlr, file, "%21s\n","-");
3898 }
3899 
3900 /** outputs timing statistics
3901  *
3902  * @pre This method can be called if SCIP is in one of the following stages:
3903  * - \ref SCIP_STAGE_PROBLEM
3904  * - \ref SCIP_STAGE_TRANSFORMED
3905  * - \ref SCIP_STAGE_INITPRESOLVE
3906  * - \ref SCIP_STAGE_PRESOLVING
3907  * - \ref SCIP_STAGE_EXITPRESOLVE
3908  * - \ref SCIP_STAGE_PRESOLVED
3909  * - \ref SCIP_STAGE_SOLVING
3910  * - \ref SCIP_STAGE_SOLVED
3911  */
3913  SCIP* scip, /**< SCIP data structure */
3914  FILE* file /**< output file */
3915  )
3916 {
3917  SCIP_Real readingtime;
3918 
3919  assert(scip != NULL);
3920  assert(scip->set != NULL);
3921 
3922  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintTimingStatistics", FALSE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3923 
3924  readingtime = SCIPgetReadingTime(scip);
3925 
3926  if( SCIPgetStage(scip) == SCIP_STAGE_PROBLEM )
3927  {
3928  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Total Time : %10.2f\n", readingtime);
3929  SCIPmessageFPrintInfo(scip->messagehdlr, file, " reading : %10.2f\n", readingtime);
3930  }
3931  else
3932  {
3933  SCIP_Real totaltime;
3934  SCIP_Real solvingtime;
3935 
3936  solvingtime = SCIPclockGetTime(scip->stat->solvingtime);
3937 
3938  if( scip->set->time_reading )
3939  totaltime = solvingtime;
3940  else
3941  totaltime = solvingtime + readingtime;
3942 
3943  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Total Time : %10.2f\n", totaltime);
3944  SCIPmessageFPrintInfo(scip->messagehdlr, file, " solving : %10.2f\n", solvingtime);
3945  SCIPmessageFPrintInfo(scip->messagehdlr, file, " presolving : %10.2f (included in solving)\n", SCIPclockGetTime(scip->stat->presolvingtime));
3946  SCIPmessageFPrintInfo(scip->messagehdlr, file, " reading : %10.2f%s\n", readingtime, scip->set->time_reading ? " (included in solving)" : "");
3947 
3948  if( scip->stat->ncopies > 0 )
3949  {
3950  SCIP_Real copytime;
3951 
3952  copytime = SCIPclockGetTime(scip->stat->copyclock);
3953 
3954  SCIPmessageFPrintInfo(scip->messagehdlr, file, " copying : %10.2f (%d #copies) (minimal %.2f, maximal %.2f, average %.2f)\n",
3955  copytime, scip->stat->ncopies, scip->stat->mincopytime, scip->stat->maxcopytime, copytime / scip->stat->ncopies);
3956  }
3957  else
3958  SCIPmessageFPrintInfo(scip->messagehdlr, file, " copying : %10.2f %s\n", 0.0, "(0 times copied the problem)");
3959  }
3960 }
3961 
3962 /** outputs expression handler statistics
3963  *
3964  * @pre This method can be called if SCIP is in one of the following stages:
3965  * - \ref SCIP_STAGE_PROBLEM
3966  * - \ref SCIP_STAGE_TRANSFORMED
3967  * - \ref SCIP_STAGE_INITPRESOLVE
3968  * - \ref SCIP_STAGE_PRESOLVING
3969  * - \ref SCIP_STAGE_EXITPRESOLVE
3970  * - \ref SCIP_STAGE_PRESOLVED
3971  * - \ref SCIP_STAGE_SOLVING
3972  * - \ref SCIP_STAGE_SOLVED
3973  */
3975  SCIP* scip, /**< SCIP data structure */
3976  FILE* file /**< output file */
3977  )
3978 {
3979  SCIP_Bool headerprinted = FALSE;
3980  int i;
3981 
3982  assert(scip != NULL);
3983  assert(scip->set != NULL);
3984 
3985  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintExpressionHandlerStatistics", FALSE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3986 
3987  for( i = 0; i < scip->set->nexprhdlrs; ++i )
3988  {
3989  SCIP_EXPRHDLR* exprhdlr = scip->set->exprhdlrs[i];
3990  assert(exprhdlr != NULL);
3991 
3992  /* skip unused expression handler */
3993  if( SCIPexprhdlrGetNCreated(exprhdlr) == 0 )
3994  continue;
3995 
3996  if( !headerprinted )
3997  {
3998  SCIPmessageFPrintInfo(scip->messagehdlr, file,
3999  "Expressions : %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s\n",
4000  "#IntEval", "IntEvalTi", "#RevProp", "RevPropTi", "DomReds", "Cutoffs", "#Estimate", "EstimTime", "Branching", "#Simplify", "SimplifyTi", "Simplified");
4001  headerprinted = TRUE;
4002  }
4003 
4004  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17s:", SCIPexprhdlrGetName(exprhdlr));
4005  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10lld", SCIPexprhdlrGetNIntevalCalls(exprhdlr));
4006  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f", SCIPexprhdlrGetIntevalTime(exprhdlr));
4007  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10lld", SCIPexprhdlrGetNReversepropCalls(exprhdlr));
4008  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f", SCIPexprhdlrGetReversepropTime(exprhdlr));
4009  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10lld", SCIPexprhdlrGetNDomainReductions(exprhdlr));
4010  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10lld", SCIPexprhdlrGetNCutoffs(exprhdlr));
4011  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10lld", SCIPexprhdlrGetNEstimateCalls(exprhdlr));
4012  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f", SCIPexprhdlrGetEstimateTime(exprhdlr));
4013  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10lld", SCIPexprhdlrGetNBranchings(exprhdlr));
4014  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10lld", SCIPexprhdlrGetNSimplifyCalls(exprhdlr));
4015  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f", SCIPexprhdlrGetSimplifyTime(exprhdlr));
4016  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10lld", SCIPexprhdlrGetNSimplifications(exprhdlr));
4017  SCIPmessageFPrintInfo(scip->messagehdlr, file, "\n");
4018  }
4019 }
4020 
4021 /** outputs NLPI statistics
4022  *
4023  * @pre This method can be called if SCIP is in one of the following stages:
4024  * - \ref SCIP_STAGE_PROBLEM
4025  * - \ref SCIP_STAGE_TRANSFORMED
4026  * - \ref SCIP_STAGE_INITPRESOLVE
4027  * - \ref SCIP_STAGE_PRESOLVING
4028  * - \ref SCIP_STAGE_EXITPRESOLVE
4029  * - \ref SCIP_STAGE_PRESOLVED
4030  * - \ref SCIP_STAGE_SOLVING
4031  * - \ref SCIP_STAGE_SOLVED
4032  */
4034  SCIP* scip, /**< SCIP data structure */
4035  FILE* file /**< output file */
4036  )
4037 {
4038  SCIP_Bool printedheader = FALSE;
4039  int i;
4040 
4041  assert(scip != NULL);
4042  assert(scip->set != NULL);
4043 
4044  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintNLPIStatistics", FALSE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
4045 
4046  for( i = 0; i < scip->set->nnlpis; ++i )
4047  {
4048  SCIP_Real solvetime;
4049  SCIP_Real evaltime = 0.0;
4050  SCIP_Longint niter;
4051  SCIP_NLPI* nlpi;
4052  int j;
4053 
4054  nlpi = scip->set->nlpis[i];
4055  assert(nlpi != NULL);
4056 
4057  /* skip unused NLP solver */
4058  if( SCIPnlpiGetNProblems(nlpi) == 0 )
4059  continue;
4060 
4061  if( !printedheader )
4062  {
4063  SCIPmessageFPrintInfo(scip->messagehdlr, file,
4064  "NLP Solvers : %10s %10s %10s %10s %s%10s %10s"
4065  " %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s"
4066  " %10s %10s %10s %10s %10s %10s %10s\n",
4067  "#Problems", "ProblemTi", "#Solves", "SolveTime",
4068  scip->set->time_nlpieval ? " EvalTime%" : "",
4069  "#Iter", "Time/Iter",
4070  "#Okay", "#TimeLimit", "#IterLimit", "#LObjLimit", "#Interrupt", "#NumError", "#EvalError", "#OutOfMem", "#LicenseEr", "#OtherTerm",
4071  "#GlobOpt", "#LocOpt", "#Feasible", "#LocInfeas", "#GlobInfea", "#Unbounded", "#Unknown"
4072  );
4073  printedheader = TRUE;
4074  }
4075 
4076  solvetime = SCIPnlpiGetSolveTime(nlpi);
4077  if( scip->set->time_nlpieval )
4078  evaltime = SCIPnlpiGetEvalTime(nlpi);
4079  niter = SCIPnlpiGetNIterations(nlpi);
4080 
4081  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17s:", SCIPnlpiGetName(nlpi));
4082  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10d", SCIPnlpiGetNProblems(nlpi));
4083  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f", SCIPnlpiGetProblemTime(nlpi));
4084  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10d", SCIPnlpiGetNSolves(nlpi));
4085  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f", solvetime);
4086  if( scip->set->time_nlpieval )
4087  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f", solvetime > 0.0 ? 100.0 * evaltime / solvetime : 0.0);
4088  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10" SCIP_LONGINT_FORMAT, niter);
4089  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f", niter > 0 ? solvetime / niter : 0.0);
4090 
4091  for( j = (int)SCIP_NLPTERMSTAT_OKAY; j <= (int)SCIP_NLPTERMSTAT_OTHER; ++j )
4093 
4094  for( j = (int)SCIP_NLPSOLSTAT_GLOBOPT; j <= (int)SCIP_NLPSOLSTAT_UNKNOWN; ++j )
4095  SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10d", SCIPnlpiGetNSolStat(nlpi, (SCIP_NLPSOLSTAT)j));
4096 
4097  SCIPmessageFPrintInfo(scip->messagehdlr, file, "\n");
4098  }
4099 }
4100 
4101 /** comparison method for statistics tables */
4102 static
4104 { /*lint --e{715}*/
4105  return (SCIPtableGetPosition((SCIP_TABLE*)elem1) - (SCIPtableGetPosition((SCIP_TABLE*)elem2)));
4106 }
4107 
4108 /** outputs solving statistics
4109  *
4110  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4111  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4112  *
4113  * @note If limits have been changed between the solution and the call to this function, the status is recomputed and
4114  * thus may to correspond to the original status.
4115  *
4116  * @pre This method can be called if SCIP is in one of the following stages:
4117  * - \ref SCIP_STAGE_INIT
4118  * - \ref SCIP_STAGE_PROBLEM
4119  * - \ref SCIP_STAGE_TRANSFORMED
4120  * - \ref SCIP_STAGE_INITPRESOLVE
4121  * - \ref SCIP_STAGE_PRESOLVING
4122  * - \ref SCIP_STAGE_EXITPRESOLVE
4123  * - \ref SCIP_STAGE_PRESOLVED
4124  * - \ref SCIP_STAGE_SOLVING
4125  * - \ref SCIP_STAGE_SOLVED
4126  */
4128  SCIP* scip, /**< SCIP data structure */
4129  FILE* file /**< output file (or NULL for standard output) */
4130  )
4131 {
4132  SCIP_TABLE** tables;
4133  int ntables;
4134  int i;
4135 
4136  assert(scip != NULL);
4137  assert(scip->set != NULL);
4138 
4139  SCIP_CALL( SCIPcheckStage(scip, "SCIPprintStatistics", TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
4140 
4141  ntables = SCIPgetNTables(scip);
4142  tables = SCIPgetTables(scip);
4143 
4144  /* sort all tables by position unless this has already been done */
4145  if( ! scip->set->tablessorted )
4146  {
4147  SCIPsortPtr((void**)tables, tablePosComp, ntables);
4148 
4149  scip->set->tablessorted = TRUE;
4150  }
4151 
4152  for( i = 0; i < ntables; ++i )
4153  {
4154  /* skip tables which are not active or only used in later stages */
4155  if( ( ! SCIPtableIsActive(tables[i]) ) || SCIPtableGetEarliestStage(tables[i]) > SCIPgetStage(scip) )
4156  continue;
4157 
4158  SCIP_CALL( SCIPtableOutput(tables[i], scip->set, file) );
4159  }
4160 
4161  return SCIP_OKAY;
4162 }
4163 
4164 /** outputs reoptimization statistics
4165  *
4166  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4167  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4168  *
4169  * @pre This method can be called if SCIP is in one of the following stages:
4170  * - \ref SCIP_STAGE_INIT
4171  * - \ref SCIP_STAGE_PROBLEM
4172  * - \ref SCIP_STAGE_TRANSFORMED
4173  * - \ref SCIP_STAGE_INITPRESOLVE
4174  * - \ref SCIP_STAGE_PRESOLVING
4175  * - \ref SCIP_STAGE_EXITPRESOLVE
4176  * - \ref SCIP_STAGE_PRESOLVED
4177  * - \ref SCIP_STAGE_SOLVING
4178  * - \ref SCIP_STAGE_SOLVED
4179  */
4181  SCIP* scip, /**< SCIP data structure */
4182  FILE* file /**< output file (or NULL for standard output) */
4183  )
4184 {
4185  SCIP_Real solving;
4186  SCIP_Real presolving;
4187  SCIP_Real updatetime;
4188 
4189  SCIP_CALL( SCIPcheckStage(scip, "SCIPprintReoptStatistics", TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
4190 
4191  assert(scip != NULL);
4192 
4193  /* skip if reoptimization is disabled */
4194  if( !scip->set->reopt_enable )
4195  return SCIP_OKAY;
4196 
4197  /* skip if not problem yet */
4198  if( scip->stat == NULL )
4199  return SCIP_OKAY;
4200 
4201  solving = SCIPclockGetTime(scip->stat->solvingtimeoverall);
4202  presolving = SCIPclockGetTime(scip->stat->presolvingtimeoverall);
4203  updatetime = SCIPclockGetTime(scip->stat->reoptupdatetime);
4204 
4205  SCIPmessageFPrintInfo(scip->messagehdlr, file, "SCIP Reopt Status : finished after %d runs.\n", scip->stat->nreoptruns);
4206  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Time (sec) :\n");
4207  SCIPmessageFPrintInfo(scip->messagehdlr, file, " solving : %10.2f\n", solving);
4208  SCIPmessageFPrintInfo(scip->messagehdlr, file, " presolving : %10.2f (included in solving)\n", presolving);
4209  SCIPmessageFPrintInfo(scip->messagehdlr, file, " save time : %10.2f\n", SCIPreoptGetSavingtime(scip->reopt));
4210  SCIPmessageFPrintInfo(scip->messagehdlr, file, " update time : %10.2f\n", updatetime);
4211  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Nodes : feas infeas pruned cutoff\n");
4212  SCIPmessageFPrintInfo(scip->messagehdlr, file, " total : %10d %10d %10d %10d\n",
4215  if( scip->stat->nreoptruns > 0 )
4216  {
4217  SCIPmessageFPrintInfo(scip->messagehdlr, file, " avg : %10.2f %10.2f %10.2f %10.2f\n",
4222  }
4223  else
4224  {
4225  SCIPmessageFPrintInfo(scip->messagehdlr, file, " avg : %10s %10s %10s %10s\n", "--", "--", "--", "--");
4226  }
4227  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Restarts : global local\n");
4228  SCIPmessageFPrintInfo(scip->messagehdlr, file, " first : %10d --\n", SCIPreoptGetFirstRestarts(scip->reopt));
4229  SCIPmessageFPrintInfo(scip->messagehdlr, file, " last : %10d --\n", SCIPreoptGetLastRestarts(scip->reopt));
4230  SCIPmessageFPrintInfo(scip->messagehdlr, file, " total : %10d %10d\n", SCIPreoptGetNRestartsGlobal(scip->reopt),
4232  if( scip->stat->nreoptruns > 0 )
4233  {
4234  SCIPmessageFPrintInfo(scip->messagehdlr, file, " avg : -- %10.2f\n",
4236  }
4237  else
4238  {
4239  SCIPmessageFPrintInfo(scip->messagehdlr, file, " avg : -- %10s\n", "--");
4240  }
4241 
4242  return SCIP_OKAY;
4243 }
4244 
4245 /** outputs history statistics about branchings on variables
4246  *
4247  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4248  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4249  *
4250  * @pre This method can be called if SCIP is in one of the following stages:
4251  * - \ref SCIP_STAGE_INIT
4252  * - \ref SCIP_STAGE_PROBLEM
4253  * - \ref SCIP_STAGE_TRANSFORMED
4254  * - \ref SCIP_STAGE_INITPRESOLVE
4255  * - \ref SCIP_STAGE_PRESOLVING
4256  * - \ref SCIP_STAGE_EXITPRESOLVE
4257  * - \ref SCIP_STAGE_PRESOLVED
4258  * - \ref SCIP_STAGE_SOLVING
4259  * - \ref SCIP_STAGE_SOLVED
4260  */
4262  SCIP* scip, /**< SCIP data structure */
4263  FILE* file /**< output file (or NULL for standard output) */
4264  )
4265 {
4266  SCIP_VAR** vars;
4267  int totalnstrongbranchs;
4268  int v;
4269 
4270  SCIP_CALL( SCIPcheckStage(scip, "SCIPprintBranchingStatistics", TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
4271 
4272  switch( scip->set->stage )
4273  {
4274  case SCIP_STAGE_INIT:
4275  case SCIP_STAGE_PROBLEM:
4276  SCIPmessageFPrintInfo(scip->messagehdlr, file, "problem not yet solved. branching statistics not available.\n");
4277  return SCIP_OKAY;
4278 
4281  case SCIP_STAGE_PRESOLVING:
4283  case SCIP_STAGE_PRESOLVED:
4284  case SCIP_STAGE_SOLVING:
4285  case SCIP_STAGE_SOLVED:
4286  SCIP_CALL( SCIPallocBufferArray(scip, &vars, scip->transprob->nvars) );
4287  for( v = 0; v < scip->transprob->nvars; ++v )
4288  {
4289  SCIP_VAR* var;
4290  int i;
4291 
4292  var = scip->transprob->vars[v];
4293  for( i = v; i > 0 && strcmp(SCIPvarGetName(var), SCIPvarGetName(vars[i-1])) < 0; i-- )
4294  vars[i] = vars[i-1];
4295  vars[i] = var;
4296  }
4297 
4298  SCIPmessageFPrintInfo(scip->messagehdlr, file, " locks branchings inferences cutoffs LP gain pscostcount gain variance \n");
4299  SCIPmessageFPrintInfo(scip->messagehdlr, file, "variable prio factor down up depth down up sb down up down up down up down up down up\n");
4300 
4301  totalnstrongbranchs = 0;
4302  for( v = 0; v < scip->transprob->nvars; ++v )
4303  {
4306  || SCIPgetVarNStrongbranchs(scip, vars[v]) > 0 )
4307  {
4308  int nstrongbranchs;
4309 
4310  nstrongbranchs = SCIPgetVarNStrongbranchs(scip, vars[v]);
4311  totalnstrongbranchs += nstrongbranchs;
4312  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",
4313  SCIPvarGetName(vars[v]),
4314  SCIPvarGetBranchPriority(vars[v]),
4315  SCIPvarGetBranchFactor(vars[v]),
4319  + SCIPvarGetAvgBranchdepth(vars[v], SCIP_BRANCHDIR_UPWARDS))/2.0 - 1.0,
4322  nstrongbranchs,
4325  100.0 * SCIPvarGetAvgCutoffs(vars[v], scip->stat, SCIP_BRANCHDIR_DOWNWARDS),
4326  100.0 * SCIPvarGetAvgCutoffs(vars[v], scip->stat, SCIP_BRANCHDIR_UPWARDS),
4327  SCIPvarGetPseudocost(vars[v], scip->stat, -1.0),
4328  SCIPvarGetPseudocost(vars[v], scip->stat, +1.0),
4333  }
4334  }
4335  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",
4338  totalnstrongbranchs,
4357 
4358  SCIPfreeBufferArray(scip, &vars);
4359 
4360  return SCIP_OKAY;
4361 
4362  default:
4363  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
4364  return SCIP_INVALIDCALL;
4365  } /*lint !e788*/
4366 }
4367 
4368 /** outputs node information display line
4369  *
4370  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4371  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4372  *
4373  * @pre This method can be called if SCIP is in one of the following stages:
4374  * - \ref SCIP_STAGE_SOLVING
4375  */
4377  SCIP* scip, /**< SCIP data structure */
4378  FILE* file, /**< output file (or NULL for standard output) */
4379  SCIP_VERBLEVEL verblevel, /**< minimal verbosity level to actually display the information line */
4380  SCIP_Bool endline /**< should the line be terminated with a newline symbol? */
4381  )
4382 {
4383  SCIP_CALL( SCIPcheckStage(scip, "SCIPprintDisplayLine", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
4384 
4385  if( (SCIP_VERBLEVEL)scip->set->disp_verblevel >= verblevel )
4386  {
4387  SCIP_CALL( SCIPdispPrintLine(scip->set, scip->messagehdlr, scip->stat, file, TRUE, endline) );
4388  }
4389 
4390  return SCIP_OKAY;
4391 }
4392 
4393 /** gets total number of implications between variables that are stored in the implication graph
4394  *
4395  * @return the total number of implications between variables that are stored in the implication graph
4396  *
4397  * @pre This method can be called if SCIP is in one of the following stages:
4398  * - \ref SCIP_STAGE_INITPRESOLVE
4399  * - \ref SCIP_STAGE_PRESOLVING
4400  * - \ref SCIP_STAGE_EXITPRESOLVE
4401  * - \ref SCIP_STAGE_PRESOLVED
4402  * - \ref SCIP_STAGE_INITSOLVE
4403  * - \ref SCIP_STAGE_SOLVING
4404  * - \ref SCIP_STAGE_SOLVED
4405  */
4407  SCIP* scip /**< SCIP data structure */
4408  )
4409 {
4410  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNImplications", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
4411 
4412  return scip->stat->nimplications;
4413 }
4414 
4415 /** stores conflict graph of binary variables' implications into a file, which can be used as input for the DOT tool
4416  *
4417  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4418  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4419  *
4420  * @pre This method can be called if SCIP is in one of the following stages:
4421  * - \ref SCIP_STAGE_TRANSFORMED
4422  * - \ref SCIP_STAGE_INITPRESOLVE
4423  * - \ref SCIP_STAGE_PRESOLVING
4424  * - \ref SCIP_STAGE_EXITPRESOLVE
4425  * - \ref SCIP_STAGE_PRESOLVED
4426  * - \ref SCIP_STAGE_INITSOLVE
4427  * - \ref SCIP_STAGE_SOLVING
4428  * - \ref SCIP_STAGE_SOLVED
4429  * - \ref SCIP_STAGE_EXITSOLVE
4430  *
4431  * @deprecated because binary implications are now stored as cliques, please use SCIPwriteCliqueGraph() instead
4432  *
4433  */ /*lint -e715*/
4435  SCIP* scip, /**< SCIP data structure */
4436  const char* filename /**< file name, or NULL for stdout */
4437  )
4438 { /*lint --e{715}*/
4439  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");
4440 
4441  return SCIP_OKAY;
4442 }
4443 
4444 /** update statistical information when a new solution was found */
4446  SCIP* scip /**< SCIP data structure */
4447  )
4448 {
4450 
4451  if( scip->primal->nsols == 1 )
4452  scip->stat->firstsolgap = scip->stat->lastsolgap;
4453 
4454  if( scip->set->stage == SCIP_STAGE_SOLVING && scip->set->misc_calcintegral )
4455  {
4457  }
4458 }
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_RETCODE SCIPprintReoptStatistics(SCIP *scip, FILE *file)
SCIP_Longint nlexduallps
Definition: struct_stat.h:189
int SCIPbendersGetNBenderscuts(SCIP_BENDERS *benders)
Definition: benders.c:6927
SCIP_Longint nprimallps
Definition: struct_stat.h:185
SCIP_Longint SCIPconflictGetNStrongbranchSuccess(SCIP_CONFLICT *conflict)
Definition: conflict.c:9318
SCIP_STAT * stat
Definition: struct_scip.h:70
void SCIPsetSortPropsName(SCIP_SET *set)
Definition: set.c:4456
SCIP_Real SCIPgetAvgPseudocostCountCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)
SCIP_Real SCIPgetFirstPrimalBound(SCIP *scip)
SCIP_Longint ndualresolvelpiterations
Definition: struct_stat.h:61
SCIP_Longint SCIPexprhdlrGetNSimplifyCalls(SCIP_EXPRHDLR *exprhdlr)
Definition: expr.c:797
SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)
SCIP_Longint SCIPexprhdlrGetNEstimateCalls(SCIP_EXPRHDLR *exprhdlr)
Definition: expr.c:753
SCIP_Longint SCIPconflictGetNLocalChgBds(SCIP_CONFLICT *conflict)
Definition: conflict.c:3807
SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6206
SCIP_Longint ninfeasleaves
Definition: struct_stat.h:77
const char * SCIPbenderscutGetName(SCIP_BENDERSCUT *benderscut)
Definition: benderscut.c:483
int SCIPpresolGetNDelConss(SCIP_PRESOL *presol)
Definition: presol.c:758
SCIP_Real SCIPgetSolvingTime(SCIP *scip)
Definition: scip_timing.c:369
SCIP_Longint SCIPgetNRootLPIterations(SCIP *scip)
void SCIPprintSeparatorStatistics(SCIP *scip, FILE *file)
SCIP_Real firstlpdualbound
Definition: struct_stat.h:121
SCIP_Real SCIPgetAvgPseudocostScoreCurrentRun(SCIP *scip)
const char * SCIPcutselGetName(SCIP_CUTSEL *cutsel)
Definition: cutsel.c:150
SCIP_Longint SCIPconflictGetNPropConflictConss(SCIP_CONFLICT *conflict)
Definition: conflict.c:5747
enum SCIP_NlpTermStat SCIP_NLPTERMSTAT
Definition: type_nlpi.h:185
SCIP_READER ** readers
Definition: struct_set.h:70
SCIP_Real SCIPnlpiGetProblemTime(SCIP_NLPI *nlpi)
Definition: nlpi.c:736
SCIP_Longint nnodelpiterations
Definition: struct_stat.h:63
int SCIPdivesetGetNSolutionCalls(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)
Definition: heur.c:487
SCIP_CUTSEL ** cutsels
Definition: struct_set.h:80
SCIP_Real SCIPheurGetSetupTime(SCIP_HEUR *heur)
Definition: heur.c:1619
SCIP_SEPA * SCIPsepaGetParentsepa(SCIP_SEPA *sepa)
Definition: sepa.c:1130
SCIP_Longint nlpsolsfound
Definition: struct_stat.h:92
internal methods for storing primal CIP solutions
int SCIPpresolGetNAggrVars(SCIP_PRESOL *presol)
Definition: presol.c:718
SCIP_Longint SCIPdivesetGetNBacktracks(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)
Definition: heur.c:604
int SCIPnlpiGetNSolves(SCIP_NLPI *nlpi)
Definition: nlpi.c:745
SCIP_Longint nlpiterations
Definition: struct_stat.h:53
const char * SCIPpricerGetName(SCIP_PRICER *pricer)
Definition: pricer.c:588
int SCIPvarGetNLocksDownType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
Definition: var.c:3289
public methods for branching and inference history structure
void SCIPprintConstraintStatistics(SCIP *scip, FILE *file)
SCIP_STAGE SCIPgetStage(SCIP *scip)
Definition: scip_general.c:356
SCIP_Real SCIPgetFirstLPLowerboundRoot(SCIP *scip)
internal methods for branch and bound tree
SCIP_Longint SCIPgetNLPIterations(SCIP *scip)
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:564
SCIP_CONFLICT * conflict
Definition: struct_scip.h:87
SCIP_Bool SCIPtableIsActive(SCIP_TABLE *table)
Definition: table.c:340
SCIP_Longint ndeactivatednodes
Definition: struct_stat.h:84
SCIP_Real SCIPvarGetBranchFactor(SCIP_VAR *var)
Definition: var.c:18070
SCIP_Longint SCIPconflictGetNPropSuccess(SCIP_CONFLICT *conflict)
Definition: conflict.c:5737
SCIP_Real SCIPpropGetRespropTime(SCIP_PROP *prop)
Definition: prop.c:1067
SCIP_Longint SCIPrelaxGetNImprovedLowerbound(SCIP_RELAX *relax)
Definition: relax.c:639
SCIP_Bool SCIPsepaIsParentsepa(SCIP_SEPA *sepa)
Definition: sepa.c:1120
int SCIPgetNConcurrentSolvers(SCIP *scip)
Definition: concurrent.c:107
public methods for memory management
int SCIPbendersGetNStrengthenCutsFound(SCIP_BENDERS *benders)
Definition: benders.c:5981
int npricerounds
Definition: struct_stat.h:224
int SCIPpricestoreGetNVars(SCIP_PRICESTORE *pricestore)
Definition: pricestore.c:600
SCIP_Longint SCIPcliquetableGetNEntries(SCIP_CLIQUETABLE *cliquetable)
Definition: implics.c:3524
SCIP_Real SCIPgetDualboundRoot(SCIP *scip)
SCIP_Real SCIPgetReadingTime(SCIP *scip)
Definition: scip_timing.c:396
SCIP_Real SCIPgetCutoffbound(SCIP *scip)
SCIP_Real SCIPgetPrimalbound(SCIP *scip)
SCIP_Longint SCIPconflictGetNBoundexceedingLPConflictConss(SCIP_CONFLICT *conflict)
Definition: conflict.c:8924
int SCIPpricestoreGetNProbvarsFound(SCIP_PRICESTORE *pricestore)
Definition: pricestore.c:642
SCIP_Longint SCIPcutpoolGetNCutsFound(SCIP_CUTPOOL *cutpool)
Definition: cutpool.c:1116
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:183
methods for implications, variable bounds, and cliques
SCIP_Longint SCIPbranchruleGetNChildren(SCIP_BRANCHRULE *branchrule)
Definition: branch.c:2154
SCIP_Longint SCIPconflictGetNAppliedGlobalConss(SCIP_CONFLICT *conflict)
Definition: conflict.c:3787
SCIP_Longint SCIPconshdlrGetNDomredsFound(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4904
SCIP_Longint nbarrierlpiterations
Definition: struct_stat.h:59
SCIP_Real SCIPpricestoreGetProbPricingTime(SCIP_PRICESTORE *pricestore)
Definition: pricestore.c:622
SCIP_Real SCIPvarGetAvgBranchdepth(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:15786
SCIP_Longint SCIPpropGetNRespropCalls(SCIP_PROP *prop)
Definition: prop.c:1097
SCIP_Longint SCIPconflictGetNBoundexceedingLPIterations(SCIP_CONFLICT *conflict)
Definition: conflict.c:8964
SCIP_CLOCK * conflictlptime
Definition: struct_stat.h:162
int SCIPpropGetNChgSides(SCIP_PROP *prop)
Definition: prop.c:1247
int nrunsbeforefirst
Definition: struct_stat.h:262
SCIP_RETCODE SCIPupdateCutoffbound(SCIP *scip, SCIP_Real cutoffbound)
#define SCIP_MAXSTRLEN
Definition: def.h:293
SCIP_Longint SCIPconshdlrGetNCutoffs(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4844
int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
Definition: var.c:3347
SCIP_Longint SCIPheurGetNBestSolsFound(SCIP_HEUR *heur)
Definition: heur.c:1587
SCIP_Real rootlowerbound
Definition: struct_stat.h:122
const char * SCIPbendersGetName(SCIP_BENDERS *benders)
Definition: benders.c:5895
const char * SCIPexprhdlrGetName(SCIP_EXPRHDLR *exprhdlr)
Definition: expr.c:525
SCIP_Longint SCIPgetNSolsFound(SCIP *scip)
SCIP_Longint SCIPgetNBarrierLPs(SCIP *scip)
SCIP_Longint SCIPconflictGetNPseudoReconvergenceLiterals(SCIP_CONFLICT *conflict)
Definition: conflict.c:9602
internal methods for clocks and timing issues
SCIP_Longint ntotalnodes
Definition: struct_stat.h:78
SCIP_Longint SCIPcomprGetNFound(SCIP_COMPR *compr)
Definition: compr.c:511
SCIP_Longint SCIPconflictGetNGlobalChgBds(SCIP_CONFLICT *conflict)
Definition: conflict.c:3777
SCIP_Real SCIPcomprGetTime(SCIP_COMPR *compr)
Definition: compr.c:541
SCIP_Longint SCIPcutselGetNCalls(SCIP_CUTSEL *cutsel)
Definition: cutsel.c:565
SCIP_Longint nrootfirstlpiterations
Definition: struct_stat.h:55
int nprops
Definition: struct_set.h:123
void SCIPprintConcsolverStatistics(SCIP *scip, FILE *file)
SCIP_Longint SCIPconflictGetNPseudoConflictLiterals(SCIP_CONFLICT *conflict)
Definition: conflict.c:9582
SCIP_Longint ndivinglps
Definition: struct_stat.h:198
SCIP_Longint SCIPconflictGetNInfeasibleLPSuccess(SCIP_CONFLICT *conflict)
Definition: conflict.c:8834
static SCIP_DECL_SORTPTRCOMP(tablePosComp)
void SCIPsetSortComprsName(SCIP_SET *set)
Definition: set.c:4735
SCIP_Longint SCIPcutselGetNRootForcedCuts(SCIP_CUTSEL *cutsel)
Definition: cutsel.c:595
SCIP_EVENTQUEUE * eventqueue
Definition: struct_scip.h:80
SCIP_Longint nsbtimesiterlimhit
Definition: struct_stat.h:112
SCIP_Longint SCIPconflictGetNPropCalls(SCIP_CONFLICT *conflict)
Definition: conflict.c:5727
SCIP_Longint SCIPsepaGetNDomredsFound(SCIP_SEPA *sepa)
Definition: sepa.c:1070
int nintvars
Definition: struct_prob.h:63
int SCIPnlpiGetNProblems(SCIP_NLPI *nlpi)
Definition: nlpi.c:727
SCIP_Real SCIPgetAvgCutoffScoreCurrentRun(SCIP *scip)
public methods for timing
SCIP_Real SCIPpricerGetTime(SCIP_PRICER *pricer)
Definition: pricer.c:662
SCIP_Longint SCIPdivesetGetNLPIterations(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)
Definition: heur.c:578
SCIP_PRIMAL * primal
Definition: struct_scip.h:85
SCIP_Longint SCIPgetNConflictDualproofsApplied(SCIP *scip)
int SCIPdivesetGetNCalls(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)
Definition: heur.c:474
SCIP_Longint SCIPsepaGetNCutsAppliedViaPool(SCIP_SEPA *sepa)
Definition: sepa.c:942
SCIP_DIVESET ** SCIPheurGetDivesets(SCIP_HEUR *heur)
Definition: heur.c:1639
SCIP_Real SCIPgetAvgConflictScore(SCIP *scip)
SCIP_RETCODE SCIPprintTransProblem(SCIP *scip, FILE *file, const char *extension, SCIP_Bool genericnames)
SCIP_Real lastsolgap
Definition: struct_stat.h:127
SCIP_Longint SCIPconflictGetNStrongbranchIterations(SCIP_CONFLICT *conflict)
Definition: conflict.c:9368
SCIP_Longint nrootstrongbranchs
Definition: struct_stat.h:203
const char * SCIPreaderGetName(SCIP_READER *reader)
Definition: reader.c:548
SCIP_Longint SCIPgetNDualLPs(SCIP *scip)
SCIP_Real SCIPsetInfinity(SCIP_SET *set)
Definition: set.c:6071
SCIP_Bool time_reading
Definition: struct_set.h:586
internal methods for displaying statistics tables
int nreoptruns
Definition: struct_stat.h:265
SCIP_SOL ** sols
Definition: struct_primal.h:48
int SCIPgetMaxDepth(SCIP *scip)
void SCIPprintStatusStatistics(SCIP *scip, FILE *file)
SCIP_Real SCIPbranchGetScore(SCIP_SET *set, SCIP_VAR *var, SCIP_Real downgain, SCIP_Real upgain)
Definition: branch.c:2181
SCIP_Longint nstrongbranchs
Definition: struct_stat.h:202
SCIP_Longint SCIPconflictGetNDualproofsInfGlobal(SCIP_CONFLICT *conflict)
Definition: conflict.c:9238
SCIP_Longint SCIPpropGetNCalls(SCIP_PROP *prop)
Definition: prop.c:1087
SCIP_RETCODE SCIPprintDisplayLine(SCIP *scip, FILE *file, SCIP_VERBLEVEL verblevel, SCIP_Bool endline)
SCIP_Real SCIPsepaGetSetupTime(SCIP_SEPA *sepa)
Definition: sepa.c:831
int SCIPpresolGetNChgCoefs(SCIP_PRESOL *presol)
Definition: presol.c:788
int SCIPsepastoreGetNCutsApplied(SCIP_SEPASTORE *sepastore)
Definition: sepastore.c:1191
SCIP_Longint SCIPgetNPrimalResolveLPs(SCIP *scip)
void SCIPprintBendersStatistics(SCIP *scip, FILE *file)
SCIP_Bool tablessorted
Definition: struct_set.h:176
SCIP_Longint nrootsblpiterations
Definition: struct_stat.h:69
SCIP_Longint SCIPconflictGetNInfeasibleLPReconvergenceConss(SCIP_CONFLICT *conflict)
Definition: conflict.c:8864
void SCIPprintTransProblemStatistics(SCIP *scip, FILE *file)
SCIP_Longint SCIPconflictGetNInfeasibleLPReconvergenceLiterals(SCIP_CONFLICT *conflict)
Definition: conflict.c:8874
void SCIPprintTimingStatistics(SCIP *scip, FILE *file)
#define FALSE
Definition: def.h:87
SCIP_SEPA ** sepas
Definition: struct_set.h:79
SCIP_Bool SCIPconshdlrDoesPresolve(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5124
SCIP_Real SCIPgetDeterministicTime(SCIP *scip)
SCIP_Longint SCIPgetNStrongbranchs(SCIP *scip)
public methods for Benders&#39; decomposition
SCIP_Longint SCIPpropGetNCutoffs(SCIP_PROP *prop)
Definition: prop.c:1107
SCIP_Longint SCIPbranchruleGetNDomredsFound(SCIP_BRANCHRULE *branchrule)
Definition: branch.c:2144
char * SCIPconcsolverGetName(SCIP_CONCSOLVER *concsolver)
Definition: concsolver.c:291
SCIP_Real SCIPinfinity(SCIP *scip)
int SCIPsnprintf(char *t, int len, const char *s,...)
Definition: misc.c:10755
SCIP_STAGE stage
Definition: struct_set.h:65
void SCIPsetSortCutsels(SCIP_SET *set)
Definition: set.c:4365
#define TRUE
Definition: def.h:86
const char * SCIPsepaGetName(SCIP_SEPA *sepa)
Definition: sepa.c:734
SCIP_Real misc_referencevalue
Definition: struct_set.h:401
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:54
SCIP_Longint SCIPconflictGetNPropConflictLiterals(SCIP_CONFLICT *conflict)
Definition: conflict.c:5757
int nenabledconss
Definition: struct_stat.h:231
SCIP_Longint SCIPcutpoolGetNCalls(SCIP_CUTPOOL *cutpool)
Definition: cutpool.c:1096
SCIP_Real SCIPexprhdlrGetEstimateTime(SCIP_EXPRHDLR *exprhdlr)
Definition: expr.c:763
SCIP_Real SCIPsepaGetTime(SCIP_SEPA *sepa)
Definition: sepa.c:841
SCIP_Longint SCIPconcsolverGetNSolsShared(SCIP_CONCSOLVER *concsolver)
Definition: concsolver.c:584
SCIP_Longint nnlps
Definition: struct_stat.h:205
SCIP_Real SCIPprobInternObjval(SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_SET *set, SCIP_Real objval)
Definition: prob.c:2129
void SCIPprintHeuristicStatistics(SCIP *scip, FILE *file)
SCIP_Real SCIPconshdlrGetEnfoLPTime(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4704
SCIP_Longint nbacktracks
Definition: struct_stat.h:87
int SCIPconshdlrGetNUpgdConss(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5014
SCIP_Longint SCIPconshdlrGetNCutsApplied(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4864
SCIP_Longint SCIPbranchruleGetNCutoffs(SCIP_BRANCHRULE *branchrule)
Definition: branch.c:2112
SCIP_Real SCIPgetAvgLowerbound(SCIP *scip)
SCIP_Longint SCIPgetNRootFirstLPIterations(SCIP *scip)
enum SCIP_VerbLevel SCIP_VERBLEVEL
Definition: type_message.h:48
internal methods for branching rules and branching candidate storage
SCIP_Longint SCIPsepaGetNCutsFound(SCIP_SEPA *sepa)
Definition: sepa.c:891
SCIP_Longint SCIPgetNNZs(SCIP *scip)
SCIP_Longint SCIPconshdlrGetNCutsFound(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4854
datastructures for concurrent solvers
SCIP_Real SCIPsolGetTime(SCIP_SOL *sol)
Definition: sol.c:2564
SCIP_Longint SCIPcutpoolGetNCutsAdded(SCIP_CUTPOOL *cutpool)
Definition: cutpool.c:1126
SCIP_Longint SCIPgetNRootStrongbranchLPIterations(SCIP *scip)
int SCIPgetNActiveConss(SCIP *scip)
public methods for problem variables
SCIP_Longint nsolsfound
Definition: struct_primal.h:39
int nheurs
Definition: struct_set.h:125
SCIP_Longint SCIPgetNBacktracks(SCIP *scip)
SCIP_Real SCIPconshdlrGetEnfoPSTime(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4714
SCIP_Longint SCIPgetNDivingLPIterations(SCIP *scip)
int maxtotaldepth
Definition: struct_stat.h:228
SCIP_Real SCIPvarGetAvgInferences(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition: var.c:16066
public methods for reoptimization
SCIP_CLOCK * barrierlptime
Definition: struct_stat.h:158
void SCIPprintPresolverStatistics(SCIP *scip, FILE *file)
SCIP_Real SCIPhistoryGetVSIDS(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
Definition: history.c:520
const char * SCIPnlpiGetName(SCIP_NLPI *nlpi)
Definition: nlpi.c:693
int SCIPpresolGetNFixedVars(SCIP_PRESOL *presol)
Definition: presol.c:708
public methods for branching rules
SCIP_Real SCIPconshdlrGetStrongBranchPropTime(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4744
SCIP_Longint SCIPcutselGetNRootCutsFiltered(SCIP_CUTSEL *cutsel)
Definition: cutsel.c:605
SCIP_Longint nnodesaboverefbound
Definition: struct_stat.h:86
int SCIPgetNCutsFoundRound(SCIP *scip)
SCIP_Longint SCIPbranchruleGetNExternCalls(SCIP_BRANCHRULE *branchrule)
Definition: branch.c:2092
SCIP_PROB * transprob
Definition: struct_scip.h:89
SCIP_Real SCIPexprhdlrGetSimplifyTime(SCIP_EXPRHDLR *exprhdlr)
Definition: expr.c:807
SCIP_PRESOL ** presols
Definition: struct_set.h:77
SCIP_CLOCK * copyclock
Definition: struct_stat.h:169
SCIP_RETCODE SCIPprimalSetCutoffbound(SCIP_PRIMAL *primal, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_Real cutoffbound, SCIP_Bool useforobjlimit)
Definition: primal.c:298
SCIP_Real rootlpbestestimate
Definition: struct_stat.h:146
#define SCIPfreeBufferArray(scip, ptr)
Definition: scip_mem.h:127
SCIP_RELAX ** relaxs
Definition: struct_set.h:78
SCIP_Real SCIPconflictGetGlobalApplTime(SCIP_CONFLICT *conflict)
Definition: conflict.c:5707
SCIP_Real SCIPdivesetGetAvgSolutionDepth(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)
Definition: heur.c:565
SCIP_Longint SCIPconflictGetNDualproofsInfNonzeros(SCIP_CONFLICT *conflict)
Definition: conflict.c:9258
int maxdepth
Definition: struct_stat.h:227
SCIP_Real SCIPexprhdlrGetIntevalTime(SCIP_EXPRHDLR *exprhdlr)
Definition: expr.c:691
public methods for SCIP variables
SCIP_Real SCIPhistoryGetAvgCutoffs(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
Definition: history.c:675
int SCIPgetNRootboundChgsRun(SCIP *scip)
SCIP_Longint SCIPconshdlrGetNCheckCalls(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4824
SCIP_Longint SCIPdivesetGetNProbingNodes(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)
Definition: heur.c:591
SCIP_Longint SCIPconflictGetNStrongbranchReconvergenceLiterals(SCIP_CONFLICT *conflict)
Definition: conflict.c:9358
SCIP_STAGE SCIPtableGetEarliestStage(SCIP_TABLE *table)
Definition: table.c:330
SCIP_Longint SCIPconflictGetNDualproofsBndSuccess(SCIP_CONFLICT *conflict)
Definition: conflict.c:9268
SCIP_Real SCIPconflictGetPseudoTime(SCIP_CONFLICT *conflict)
Definition: conflict.c:9542
SCIP_CLOCK * nlpsoltime
Definition: struct_stat.h:168
void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)
Definition: scip_message.c:111
SCIP_Longint SCIPrelaxGetNCalls(SCIP_RELAX *relax)
Definition: relax.c:619
int SCIPreoptGetLastRestarts(SCIP_REOPT *reopt)
Definition: reopt.c:4992
SCIP_Longint SCIPconflictGetNInfeasibleLPConflictLiterals(SCIP_CONFLICT *conflict)
Definition: conflict.c:8854
SCIP_Longint SCIPconflictGetNPropReconvergenceConss(SCIP_CONFLICT *conflict)
Definition: conflict.c:5767
SCIP_Longint nlpbestsolsfound
Definition: struct_stat.h:96
int SCIPnlpiGetNSolStat(SCIP_NLPI *nlpi, SCIP_NLPSOLSTAT solstatus)
Definition: nlpi.c:794
void SCIPprintBranchruleStatistics(SCIP *scip, FILE *file)
SCIP_Real dualzeroittime
Definition: struct_stat.h:129
SCIP_Real SCIPrelaxGetTime(SCIP_RELAX *relax)
Definition: relax.c:609
SCIP_RETCODE SCIPprintStatistics(SCIP *scip, FILE *file)
SCIP_Real SCIPpresolGetSetupTime(SCIP_PRESOL *presol)
Definition: presol.c:688
SCIP_Longint SCIPbenderscutGetNFound(SCIP_BENDERSCUT *benderscut)
Definition: benderscut.c:534
SCIP_Real SCIPbenderscutGetTime(SCIP_BENDERSCUT *benderscut)
Definition: benderscut.c:564
void SCIPsetSortHeursName(SCIP_SET *set)
Definition: set.c:4661
int nbranchrules
Definition: struct_set.h:133
Definition: heur_padm.c:123
SCIP_PROB * origprob
Definition: struct_scip.h:71
SCIP_Real SCIPgetAvgCutoffs(SCIP *scip, SCIP_BRANCHDIR dir)
SCIP_Longint nexternalsolsfound
Definition: struct_stat.h:100
int SCIPconshdlrGetStartNActiveConss(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4934
SCIP_Longint SCIPconflictGetNDualproofsInfSuccess(SCIP_CONFLICT *conflict)
Definition: conflict.c:9228
SCIP_Real SCIPnlpiGetEvalTime(SCIP_NLPI *nlpi)
Definition: nlpi.c:766
int SCIPreoptGetNTotalInfNodes(SCIP_REOPT *reopt)
Definition: reopt.c:5072
SCIP_Real SCIPnlpiGetSolveTime(SCIP_NLPI *nlpi)
Definition: nlpi.c:754
SCIP_Real SCIPhistoryGetPseudocost(SCIP_HISTORY *history, SCIP_Real solvaldelta)
Definition: history.c:430
SCIP_Real SCIPgetLowerboundRoot(SCIP *scip)
int SCIPpropGetNPresolCalls(SCIP_PROP *prop)
Definition: prop.c:1257
internal methods for branching and inference history
int nrootintfixings
Definition: struct_stat.h:215
int ncutsels
Definition: struct_set.h:121
SCIP_Real SCIPconflictGetStrongbranchTime(SCIP_CONFLICT *conflict)
Definition: conflict.c:9218
SCIP_Real SCIPrelaxGetImprovedLowerboundTime(SCIP_RELAX *relax)
Definition: relax.c:659
SCIP_Longint SCIPconflictGetNAppliedLocalLiterals(SCIP_CONFLICT *conflict)
Definition: conflict.c:3827
public methods for numerical tolerances
internal methods for collecting primal CIP solutions and primal informations
SCIP_Longint SCIPconflictGetNPseudoConflictConss(SCIP_CONFLICT *conflict)
Definition: conflict.c:9572
int SCIPgetNActiveBenders(SCIP *scip)
Definition: scip_benders.c:523
SCIP_Bool reopt_enable
Definition: struct_set.h:504
int SCIPconshdlrGetNFixedVars(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4944
SCIP_Longint nsblpiterations
Definition: struct_stat.h:68
SCIP_Real primalzeroittime
Definition: struct_stat.h:128
public functions to work with algebraic expressions
int nrootboundchgs
Definition: struct_stat.h:213
public methods for querying solving statistics
SCIP_HISTORY * glbhistorycrun
Definition: struct_stat.h:173
int SCIPpresolGetNChgVarTypes(SCIP_PRESOL *presol)
Definition: presol.c:728
SCIP_RETCODE SCIPprintBranchingStatistics(SCIP *scip, FILE *file)
int SCIPconshdlrGetNChgSides(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5034
SCIP_Longint SCIPgetNDualResolveLPIterations(SCIP *scip)
SCIP_NLPI ** nlpis
Definition: struct_set.h:98
SCIP_Real dualbound
Definition: struct_prob.h:45
SCIP_PRICESTORE * pricestore
Definition: struct_scip.h:92
void SCIPprobPrintStatistics(SCIP_PROB *prob, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
Definition: prob.c:2211
enum SCIP_BranchDir SCIP_BRANCHDIR
Definition: type_history.h:39
int SCIPconshdlrGetNChgBds(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4974
int SCIPtableGetPosition(SCIP_TABLE *table)
Definition: table.c:320
SCIP_Real SCIPgetFirstLPDualboundRoot(SCIP *scip)
SCIP_Longint nlexduallpiterations
Definition: struct_stat.h:58
int SCIPbendersGetNCalls(SCIP_BENDERS *benders)
Definition: benders.c:5961
SCIP_MEM * mem
Definition: struct_scip.h:62
public methods for managing constraints
SCIP_Real SCIPhistoryGetPseudocostVariance(SCIP_HISTORY *history, SCIP_BRANCHDIR direction)
Definition: history.c:444
int SCIPbendersGetNTransferredCuts(SCIP_BENDERS *benders)
Definition: benders.c:6672
SCIP_Real barrierzeroittime
Definition: struct_stat.h:130
SCIP_Real SCIPvarGetPseudocost(SCIP_VAR *var, SCIP_STAT *stat, SCIP_Real solvaldelta)
Definition: var.c:14476
SCIP_Longint SCIPcutpoolGetNRootCalls(SCIP_CUTPOOL *cutpool)
Definition: cutpool.c:1106
SCIP_Longint nobjleaves
Definition: struct_stat.h:75
SCIP_Longint SCIPconcsolverGetNSolsRecvd(SCIP_CONCSOLVER *concsolver)
Definition: concsolver.c:574
SCIP_Real SCIPsolGetObj(SCIP_SOL *sol, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob)
Definition: sol.c:1537
SCIP_Longint npssolsfound
Definition: struct_stat.h:94
int SCIPgetNCutsApplied(SCIP *scip)
SCIP_Real SCIPconcsolverGetSolvingTime(SCIP_CONCSOLVER *concsolver)
Definition: concsolver.c:534
SCIP_Longint SCIPconflictGetNInfeasibleLPConflictConss(SCIP_CONFLICT *conflict)
Definition: conflict.c:8844
int SCIPpricestoreGetNVarsApplied(SCIP_PRICESTORE *pricestore)
Definition: pricestore.c:662
public methods for displaying statistic tables
const char * SCIPheurGetName(SCIP_HEUR *heur)
Definition: heur.c:1441
SCIP_Longint SCIPcutselGetNRootCalls(SCIP_CUTSEL *cutsel)
Definition: cutsel.c:575
SCIP_Real mincopytime
Definition: struct_stat.h:132
int SCIPreoptGetFirstRestarts(SCIP_REOPT *reopt)
Definition: reopt.c:4982
public methods for Benders decomposition
internal methods for storing and manipulating the main problem
#define SCIPerrorMessage
Definition: pub_message.h:55
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4175
SCIP_Longint SCIPgetNNodeLPs(SCIP *scip)
SCIP_Bool SCIPsyncstoreIsInitialized(SCIP_SYNCSTORE *syncstore)
Definition: syncstore.c:775
SCIP_Real SCIPconshdlrGetCheckTime(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4754
SCIP_EVENTFILTER * eventfilter
Definition: struct_scip.h:79
void SCIPstoreSolutionGap(SCIP *scip)
SCIP_Real SCIPbranchruleGetSetupTime(SCIP_BRANCHRULE *branchrule)
Definition: branch.c:2062
SCIP_Longint SCIPbenderscutGetNCalls(SCIP_BENDERSCUT *benderscut)
Definition: benderscut.c:524
SCIP_Real SCIPpropGetSetupTime(SCIP_PROP *prop)
Definition: prop.c:1025
SCIP_Longint SCIPsepaGetNRootCalls(SCIP_SEPA *sepa)
Definition: sepa.c:861
int SCIPreoptGetNRestartsGlobal(SCIP_REOPT *reopt)
Definition: reopt.c:4952
SCIP_Longint nbestsolsfound
Definition: struct_primal.h:42
SCIP_Longint SCIPconflictGetNBoundexceedingLPReconvergenceConss(SCIP_CONFLICT *conflict)
Definition: conflict.c:8944
SCIP_Longint SCIPdivesetGetNSols(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)
Definition: heur.c:630
SCIP_Longint SCIPconshdlrGetNRespropCalls(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4834
enum SCIP_NlpSolStat SCIP_NLPSOLSTAT
Definition: type_nlpi.h:159
SCIP_SYNCSTORE * syncstore
Definition: struct_scip.h:100
int SCIPgetNCutsFound(SCIP *scip)
SCIP_Real SCIPcutselGetSetupTime(SCIP_CUTSEL *cutsel)
Definition: cutsel.c:545
SCIP_Longint nconflictlpiterations
Definition: struct_stat.h:70
SCIP_CLOCK * pseudosoltime
Definition: struct_stat.h:165
SCIP_Real SCIPgetDualbound(SCIP *scip)
SCIP_Longint nrelaxbestsolsfound
Definition: struct_stat.h:97
SCIP_Longint SCIPsepaGetNCutoffs(SCIP_SEPA *sepa)
Definition: sepa.c:881
SCIP_Longint SCIPexprhdlrGetNSimplifications(SCIP_EXPRHDLR *exprhdlr)
Definition: expr.c:817
SCIP_Longint SCIPconflictGetNPseudoReconvergenceConss(SCIP_CONFLICT *conflict)
Definition: conflict.c:9592
SCIP_RETCODE SCIPcheckStage(SCIP *scip, const char *method, SCIP_Bool init, SCIP_Bool problem, SCIP_Bool transforming, SCIP_Bool transformed, SCIP_Bool initpresolve, SCIP_Bool presolving, SCIP_Bool exitpresolve, SCIP_Bool presolved, SCIP_Bool initsolve, SCIP_Bool solving, SCIP_Bool solved, SCIP_Bool exitsolve, SCIP_Bool freetrans, SCIP_Bool freescip)
Definition: debug.c:2177
SCIP_STATUS SCIPgetStatus(SCIP *scip)
Definition: scip_general.c:474
SCIP_HEUR * firstprimalheur
Definition: struct_stat.h:176
SCIP_Real SCIPgetTransGap(SCIP *scip)
SCIP_Real SCIPconshdlrGetSepaTime(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4694
SCIP_Longint SCIPcutselGetNLocalCutsFiltered(SCIP_CUTSEL *cutsel)
Definition: cutsel.c:635
SCIP_Longint SCIPgetNResolveLPIterations(SCIP *scip)
SCIP_CONSHDLR ** conshdlrs
Definition: struct_set.h:72
SCIP_Longint SCIPconflictGetNAppliedLocalConss(SCIP_CONFLICT *conflict)
Definition: conflict.c:3817
void SCIPprintConflictStatistics(SCIP *scip, FILE *file)
SCIP_Longint ninitlpiterations
Definition: struct_stat.h:64
SCIP_CONFLICTSTORE * conflictstore
Definition: struct_scip.h:95
SCIP_CLOCK * solvingtimeoverall
Definition: struct_stat.h:152
SCIP_Longint SCIPnlpiGetNIterations(SCIP_NLPI *nlpi)
Definition: nlpi.c:775
int SCIPconshdlrGetNDelConss(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4994
void SCIPprintCompressionStatistics(SCIP *scip, FILE *file)
SCIP_RETCODE SCIPprintStage(SCIP *scip, FILE *file)
Definition: scip_general.c:378
SCIP_RETCODE SCIPtableOutput(SCIP_TABLE *table, SCIP_SET *set, FILE *file)
Definition: table.c:263
const char * SCIPvarGetName(SCIP_VAR *var)
Definition: var.c:17251
SCIP_Real SCIPconflictGetBoundexceedingLPTime(SCIP_CONFLICT *conflict)
Definition: conflict.c:8894
SCIP_Real SCIPclockGetTime(SCIP_CLOCK *clck)
Definition: clock.c:429
SCIP_REOPT * reopt
Definition: struct_scip.h:76
int SCIPgetNRootboundChgs(SCIP *scip)
void SCIPprintLPStatistics(SCIP *scip, FILE *file)
SCIP_Longint SCIPgetNDelayedCutoffs(SCIP *scip)
int SCIPconshdlrGetNChgCoefs(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5024
SCIP_RETCODE SCIPprintOrigProblem(SCIP *scip, FILE *file, const char *extension, SCIP_Bool genericnames)
void SCIPprintPropagatorStatistics(SCIP *scip, FILE *file)
#define NULL
Definition: lpi_spx1.cpp:155
SCIP_HEUR * SCIPsolGetHeur(SCIP_SOL *sol)
Definition: sol.c:2604
SCIP_Longint SCIPbranchruleGetNConssFound(SCIP_BRANCHRULE *branchrule)
Definition: branch.c:2134
SCIP_Longint SCIPconshdlrGetNPropCalls(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4814
SCIP_Longint nprimalresolvelpiterations
Definition: struct_stat.h:60
SCIP_Longint SCIPconflictGetNStrongbranchReconvergenceConss(SCIP_CONFLICT *conflict)
Definition: conflict.c:9348
int nrelaxs
Definition: struct_set.h:117
SCIP_Longint SCIPrelaxGetNReducedDomains(SCIP_RELAX *relax)
Definition: relax.c:669
int nseparounds
Definition: struct_stat.h:225
SCIP_HISTORY * glbhistory
Definition: struct_stat.h:172
#define REALABS(x)
Definition: def.h:201
SCIP_Longint SCIPconflictGetNDualproofsBndNonzeros(SCIP_CONFLICT *conflict)
Definition: conflict.c:9298
SCIP_Longint SCIPpropGetNDomredsFound(SCIP_PROP *prop)
Definition: prop.c:1117
SCIP_Longint nconflictlps
Definition: struct_stat.h:204
SCIP_Longint SCIPcomprGetNCalls(SCIP_COMPR *compr)
Definition: compr.c:501
public methods for primal CIP solutions
const char * SCIPrelaxGetName(SCIP_RELAX *relax)
Definition: relax.c:533
SCIP_Longint SCIPconflictGetNStrongbranchConflictLiterals(SCIP_CONFLICT *conflict)
Definition: conflict.c:9338
void SCIPsortPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
internal methods for global SCIP settings
internal methods for storing conflicts
#define SCIP_CALL(x)
Definition: def.h:384
SCIP_Longint SCIPconflictGetNDualproofsBndLocal(SCIP_CONFLICT *conflict)
Definition: conflict.c:9288
SCIP_Real SCIPgetLowerbound(SCIP *scip)
SCIP_Bool SCIPisPrimalboundSol(SCIP *scip)
int SCIPconflictstoreGetInitPoolSize(SCIP_CONFLICTSTORE *conflictstore)
SCIP main data structure.
SCIP_Real SCIPpropGetPresolTime(SCIP_PROP *prop)
Definition: prop.c:1077
SCIP_Longint SCIPbranchruleGetNLPCalls(SCIP_BRANCHRULE *branchrule)
Definition: branch.c:2082
SCIP_Longint SCIPconshdlrGetNConssFound(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4894
SCIP_Real SCIPgetAvgPseudocostCurrentRun(SCIP *scip, SCIP_Real solvaldelta)
SCIP_Longint SCIPgetNTotalNodes(SCIP *scip)
SCIP_Real SCIPbranchruleGetTime(SCIP_BRANCHRULE *branchrule)
Definition: branch.c:2072
SCIP_Longint nsbbestsolsfound
Definition: struct_stat.h:99
SCIP_Real SCIPvarGetPseudocostCount(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:14572
SCIP_Longint nduallpiterations
Definition: struct_stat.h:57
SCIP_Longint nbarrierzeroitlps
Definition: struct_stat.h:191
SCIP_Longint SCIPconflictGetNPseudoSuccess(SCIP_CONFLICT *conflict)
Definition: conflict.c:9562
int nexprhdlrs
Definition: struct_set.h:141
SCIP_EXPRHDLR ** exprhdlrs
Definition: struct_set.h:92
SCIP_Longint SCIPgetNBarrierLPIterations(SCIP *scip)
internal methods for storing priced variables
SCIP_Real SCIPhistoryGetPseudocostCount(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
Definition: history.c:468
int SCIPheurGetNDivesets(SCIP_HEUR *heur)
Definition: heur.c:1649
SCIP_Real vsidsweight
Definition: struct_stat.h:123
int nsepas
Definition: struct_set.h:119
int SCIPpropGetNChgBds(SCIP_PROP *prop)
Definition: prop.c:1187
SCIP_Longint SCIPgetNPrimalResolveLPIterations(SCIP *scip)
SCIP_Longint SCIPheurGetNCalls(SCIP_HEUR *heur)
Definition: heur.c:1567
void SCIPprintRootStatistics(SCIP *scip, FILE *file)
SCIP_Longint SCIPconflictGetNInfeasibleLPCalls(SCIP_CONFLICT *conflict)
Definition: conflict.c:8824
internal methods for storing separated cuts
SCIP_RETCODE SCIPreaderWrite(SCIP_READER *reader, SCIP_PROB *prob, SCIP_SET *set, FILE *file, const char *extension, SCIP_Bool genericnames, SCIP_RESULT *result)
Definition: reader.c:261
void SCIPsetSortPresolsName(SCIP_SET *set)
Definition: set.c:4158
SCIP_Longint nprimalresolvelps
Definition: struct_stat.h:192
SCIP_Longint nresolveinstablelps
Definition: struct_stat.h:71
SCIP_Longint SCIPconcsolverGetNNodes(SCIP_CONCSOLVER *concsolver)
Definition: concsolver.c:564
SCIP_Bool SCIPconshdlrNeedsCons(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5114
SCIP_Longint SCIPconcsolverGetNTighterIntBnds(SCIP_CONCSOLVER *concsolver)
Definition: concsolver.c:604
SCIP_CLOCK * divinglptime
Definition: struct_stat.h:160
SCIP_Longint nprobboundchgs
Definition: struct_stat.h:108
SCIP_CLOCK * presolvingtimeoverall
Definition: struct_stat.h:154
SCIP_Longint SCIPgetNNodeLPIterations(SCIP *scip)
SCIP_Longint SCIPcutselGetNRootCuts(SCIP_CUTSEL *cutsel)
Definition: cutsel.c:585
SCIP_Real SCIPconshdlrGetRespropTime(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4764
SCIP_CUTPOOL * cutpool
Definition: struct_scip.h:96
SCIP_BRANCHRULE ** branchrules
Definition: struct_set.h:88
SCIP_Real SCIPtreeGetAvgLowerbound(SCIP_TREE *tree, SCIP_Real cutoffbound)
Definition: tree.c:7337
SCIP_Longint nduallps
Definition: struct_stat.h:187
SCIP_CLIQUETABLE * cliquetable
Definition: struct_scip.h:88
SCIP_Longint SCIPbranchruleGetNCutsFound(SCIP_BRANCHRULE *branchrule)
Definition: branch.c:2122
SCIP_Longint SCIPsepaGetNCalls(SCIP_SEPA *sepa)
Definition: sepa.c:851
SCIP_Real SCIPgetAvgInferencesCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)
int SCIPreoptGetNTotalFeasNodes(SCIP_REOPT *reopt)
Definition: reopt.c:5012
internal methods for problem variables
data structures and methods for collecting reoptimization information
the function declarations for the synchronization store
#define SCIPallocBufferArray(scip, ptr, num)
Definition: scip_mem.h:115
SCIP_SEPASTORE * sepastore
Definition: struct_scip.h:93
SCIP_Bool SCIPbendersIsActive(SCIP_BENDERS *benders)
Definition: benders.c:2661
SCIP_Longint nisstoppedcalls
Definition: struct_stat.h:206
SCIP_Longint SCIPconshdlrGetNEnfoLPCalls(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4784
public data structures and miscellaneous methods
#define SCIP_Bool
Definition: def.h:84
int SCIPbendersGetNStrengthenCalls(SCIP_BENDERS *benders)
Definition: benders.c:5991
int SCIPgetMaxTotalDepth(SCIP *scip)
int SCIPdivesetGetMinDepth(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)
Definition: heur.c:500
void SCIPsetSortSepasName(SCIP_SET *set)
Definition: set.c:4306
SCIP_Longint ndualresolvelps
Definition: struct_stat.h:193
SCIP_CLOCK * sbsoltime
Definition: struct_stat.h:166
SCIP_Real SCIPpresolGetTime(SCIP_PRESOL *presol)
Definition: presol.c:698
SCIP_Longint SCIPconshdlrGetNEnfoRelaxCalls(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4804
int SCIPbendersGetNStrengthenFails(SCIP_BENDERS *benders)
Definition: benders.c:6001
public methods for storing cuts in a cut pool
SCIP_CLOCK * presolvingtime
Definition: struct_stat.h:153
SCIP_Longint SCIPsolGetNodenum(SCIP_SOL *sol)
Definition: sol.c:2584
void SCIPprintRelaxatorStatistics(SCIP *scip, FILE *file)
void SCIPprintTreeStatistics(SCIP *scip, FILE *file)
int nbinvars
Definition: struct_prob.h:62
SCIP_BENDERS ** SCIPgetBenders(SCIP *scip)
Definition: scip_benders.c:499
void SCIPprintSolutionStatistics(SCIP *scip, FILE *file)
SCIP_Real SCIPconshdlrGetPresolTime(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4684
int SCIPpresolGetNCalls(SCIP_PRESOL *presol)
Definition: presol.c:808
SCIP_Longint SCIPsepaGetNConssFound(SCIP_SEPA *sepa)
Definition: sepa.c:1060
SCIP_Longint nearlybacktracks
Definition: struct_stat.h:85
SCIP_Longint SCIPexprhdlrGetNCutoffs(SCIP_EXPRHDLR *exprhdlr)
Definition: expr.c:721
SCIP_Real SCIPgetPseudocostVariance(SCIP *scip, SCIP_BRANCHDIR branchdir, SCIP_Bool onlycurrentrun)
int SCIPvarGetBranchPriority(SCIP_VAR *var)
Definition: var.c:18082
public methods for statistics table plugins
SCIP_Real SCIPgetGap(SCIP *scip)
SCIP_Real SCIPgetAvgConflictlengthScoreCurrentRun(SCIP *scip)
internal methods for input file readers
void SCIPprintExpressionHandlerStatistics(SCIP *scip, FILE *file)
SCIP_HEUR ** heurs
Definition: struct_set.h:83
SCIP_RETCODE SCIPwriteImplicationConflictGraph(SCIP *scip, const char *filename)
SCIP_Longint nrepropcutoffs
Definition: struct_stat.h:91
#define MAX(x, y)
Definition: tclique_def.h:83
public methods for variable pricers
int nreaders
Definition: struct_set.h:106
int SCIPpropGetNChgCoefs(SCIP_PROP *prop)
Definition: prop.c:1237
SCIP_Longint SCIPgetNPrimalLPs(SCIP *scip)
methods for debugging
int SCIPreoptGetNTotalCutoffReoptnodes(SCIP_REOPT *reopt)
Definition: reopt.c:5052
SCIP_Bool misc_showdivingstats
Definition: struct_set.h:407
SCIP_Longint SCIPconshdlrGetNEnfoPSCalls(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4794
SCIP_Longint SCIPexprhdlrGetNDomainReductions(SCIP_EXPRHDLR *exprhdlr)
Definition: expr.c:731
const char * SCIPpresolGetName(SCIP_PRESOL *presol)
Definition: presol.c:590
datastructures for block memory pools and memory buffers
SCIP_BENDERS ** benders
Definition: struct_set.h:101
int SCIPpropGetNFixedVars(SCIP_PROP *prop)
Definition: prop.c:1157
SCIP_Longint SCIPsepaGetNCutsAddedViaPool(SCIP_SEPA *sepa)
Definition: sepa.c:912
SCIP_Longint SCIPsepaGetNCutsAddedDirect(SCIP_SEPA *sepa)
Definition: sepa.c:922
SCIP_Real SCIPconshdlrGetPropTime(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4734
int SCIPsepastoreGetNCutsAdded(SCIP_SEPASTORE *sepastore)
Definition: sepastore.c:1151
SCIP_Longint SCIPconflictGetNStrongbranchConflictConss(SCIP_CONFLICT *conflict)
Definition: conflict.c:9328
int SCIPpropGetNAddConss(SCIP_PROP *prop)
Definition: prop.c:1217
SCIP_Real SCIPconshdlrGetEnfoRelaxTime(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4724
int SCIPbendersGetNCutsFound(SCIP_BENDERS *benders)
Definition: benders.c:5971
SCIP_Longint SCIPgetNConflictConssFound(SCIP *scip)
int SCIPsyncstoreGetWinner(SCIP_SYNCSTORE *syncstore)
Definition: syncstore.c:516
SCIP_Real SCIPgetAvgCutoffsCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)
void SCIPprintNLPStatistics(SCIP *scip, FILE *file)
SCIP_Longint SCIPgetNDualResolveLPs(SCIP *scip)
SCIP_Longint nresolveinstablelpiters
Definition: struct_stat.h:72
SCIP_Longint SCIPgetNDualLPIterations(SCIP *scip)
int SCIPgetNRuns(SCIP *scip)
SCIP_Real maxcopytime
Definition: struct_stat.h:131
int SCIPconflictGetNConflicts(SCIP_CONFLICT *conflict)
Definition: conflict.c:3747
SCIP_Longint SCIPconflictGetNBoundexceedingLPCalls(SCIP_CONFLICT *conflict)
Definition: conflict.c:8904
int SCIPdivesetGetMinSolutionDepth(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)
Definition: heur.c:539
SCIP_CLOCK * resolveinstablelptime
Definition: struct_stat.h:159
SCIP_Longint SCIPsepaGetNCutsAppliedDirect(SCIP_SEPA *sepa)
Definition: sepa.c:952
SCIP_Longint SCIPgetNConflictConssApplied(SCIP *scip)
datastructures for problem statistics
SCIP_Real SCIPpropGetStrongBranchPropTime(SCIP_PROP *prop)
Definition: prop.c:1057
SCIP_Longint SCIPgetNObjlimLeaves(SCIP *scip)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPbenderscutGetSetupTime(SCIP_BENDERSCUT *benderscut)
Definition: benderscut.c:554
SCIP_Longint SCIPhistoryGetNBranchings(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
Definition: history.c:623
int SCIPconflictstoreGetMaxPoolSize(SCIP_CONFLICTSTORE *conflictstore)
SCIP_Longint SCIPconflictGetNBoundexceedingLPReconvergenceLiterals(SCIP_CONFLICT *conflict)
Definition: conflict.c:8954
SCIP_CLOCK * relaxsoltime
Definition: struct_stat.h:164
int SCIPgetNBenders(SCIP *scip)
Definition: scip_benders.c:512
int SCIPpropGetNAggrVars(SCIP_PROP *prop)
Definition: prop.c:1167
SCIP_Longint nnz
Definition: struct_stat.h:180
helper functions for concurrent scip solvers
public methods for NLP solver interfaces
const char * SCIPpropGetName(SCIP_PROP *prop)
Definition: prop.c:932
SCIP_CLOCK * lexduallptime
Definition: struct_stat.h:157
void SCIPprintNLPIStatistics(SCIP *scip, FILE *file)
void SCIPprintPricerStatistics(SCIP *scip, FILE *file)
SCIP_Longint nnodesbeforefirst
Definition: struct_stat.h:113
int SCIPconshdlrGetNPresolCalls(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5044
int SCIPpresolGetNChgSides(SCIP_PRESOL *presol)
Definition: presol.c:798
SCIP_Longint SCIPconflictGetNPseudoCalls(SCIP_CONFLICT *conflict)
Definition: conflict.c:9552
SCIP_Longint nrootlpiterations
Definition: struct_stat.h:54
public methods for Benders&#39; decomposition cuts
SCIP_Longint SCIPexprhdlrGetNIntevalCalls(SCIP_EXPRHDLR *exprhdlr)
Definition: expr.c:681
SCIP_Real SCIPhistoryGetCutoffSum(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
Definition: history.c:662
SCIP_Real SCIPgetAvgDualbound(SCIP *scip)
SCIP_COMPR ** comprs
Definition: struct_set.h:84
datastructures for storing and manipulating the main problem
int SCIPpropGetNChgVarTypes(SCIP_PROP *prop)
Definition: prop.c:1177
SCIP_CLOCK * strongbranchtime
Definition: struct_stat.h:161
methods for sorting joint arrays of various types
SCIP_Longint SCIPgetNResolveLPs(SCIP *scip)
SCIP_Real SCIPgetAvgCutoffScore(SCIP *scip)
void SCIPstatUpdatePrimalDualIntegrals(SCIP_STAT *stat, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_Real upperbound, SCIP_Real lowerbound)
Definition: stat.c:450
int SCIPconshdlrGetNChgVarTypes(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4964
SCIP_Real firstsolgap
Definition: struct_stat.h:126
public methods for presolvers
SCIP_Real SCIPconflictGetInfeasibleLPTime(SCIP_CONFLICT *conflict)
Definition: conflict.c:8814
const char * SCIPcomprGetName(SCIP_COMPR *compr)
Definition: compr.c:447
SCIP_BENDERSCUT ** SCIPbendersGetBenderscuts(SCIP_BENDERS *benders)
Definition: benders.c:6910
SCIP_Longint SCIPgetNNodeInitLPIterations(SCIP *scip)
general public methods
SCIP_Longint SCIPgetNNodeInitLPs(SCIP *scip)
SCIP_Real SCIPgetAvgConflictlengthScore(SCIP *scip)
int SCIPconshdlrGetMaxNActiveConss(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4924
int SCIPpresolGetNAddHoles(SCIP_PRESOL *presol)
Definition: presol.c:748
enum SCIP_DiveContext SCIP_DIVECONTEXT
Definition: type_heur.h:63
int nactiveconss
Definition: struct_stat.h:230
BMS_BLKMEM * probmem
Definition: struct_mem.h:40
SCIP_Longint SCIPdivesetGetNConflicts(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)
Definition: heur.c:617
SCIP_Real SCIPconcsolverGetSyncTime(SCIP_CONCSOLVER *concsolver)
Definition: concsolver.c:544
SCIP_Longint SCIPconflictGetNBoundexceedingLPSuccess(SCIP_CONFLICT *conflict)
Definition: conflict.c:8914
int SCIPpricestoreGetNVarsFound(SCIP_PRICESTORE *pricestore)
Definition: pricestore.c:652
SCIP_Real SCIPhistoryGetInferenceSum(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
Definition: history.c:636
SCIP_Longint SCIPexprhdlrGetNReversepropCalls(SCIP_EXPRHDLR *exprhdlr)
Definition: expr.c:701
SCIP_TABLE ** SCIPgetTables(SCIP *scip)
Definition: scip_table.c:98
public methods for solutions
internal methods for conflict analysis
SCIP_Longint SCIPgetNStrongbranchLPIterations(SCIP *scip)
SCIP_Bool SCIPprimalUpperboundIsSol(SCIP_PRIMAL *primal, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob)
Definition: primal.c:569
SCIP_Longint SCIPbranchruleGetNPseudoCalls(SCIP_BRANCHRULE *branchrule)
Definition: branch.c:2102
void SCIPsetSortRelaxsName(SCIP_SET *set)
Definition: set.c:4232
int SCIPgetNReoptRuns(SCIP *scip)
SCIP_VERBLEVEL disp_verblevel
Definition: struct_set.h:280
SCIP_Longint SCIPgetNDivingLPs(SCIP *scip)
int nactivepricers
Definition: struct_set.h:109
SCIP_Longint SCIPcutselGetNLocalCuts(SCIP_CUTSEL *cutsel)
Definition: cutsel.c:615
void SCIPprintCutselectorStatistics(SCIP *scip, FILE *file)
int SCIPgetNPricevars(SCIP *scip)
SCIP_Longint SCIPrelaxGetNSeparatedCuts(SCIP_RELAX *relax)
Definition: relax.c:679
SCIP_Longint SCIPgetNPrimalLPIterations(SCIP *scip)
SCIP_CLOCK * solvingtime
Definition: struct_stat.h:151
SCIP_Longint nbarrierlps
Definition: struct_stat.h:190
public methods for tree compressions
SCIP_Longint nprimalzeroitlps
Definition: struct_stat.h:186
SCIP_CLOCK * primallptime
Definition: struct_stat.h:155
int conf_maxstoresize
Definition: struct_set.h:215
SCIP_Real SCIPgetAvgPseudocostCount(SCIP *scip, SCIP_BRANCHDIR dir)
SCIP_Longint nnodezeroitlps
Definition: struct_stat.h:196
SCIP_SET * set
Definition: struct_scip.h:63
int SCIPgetNPriceRounds(SCIP *scip)
SCIP_Real SCIPcomprGetSetupTime(SCIP_COMPR *compr)
Definition: compr.c:531
SCIP_Real SCIPdivesetGetAvgDepth(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)
Definition: heur.c:526
SCIP_Longint npsbestsolsfound
Definition: struct_stat.h:98
SCIP_PROP ** props
Definition: struct_set.h:81
SCIP_Longint SCIPexprhdlrGetNBranchings(SCIP_EXPRHDLR *exprhdlr)
Definition: expr.c:777
public methods for message output
SCIP_Real upperbound
Definition: struct_primal.h:45
int SCIPpricerGetNCalls(SCIP_PRICER *pricer)
Definition: pricer.c:632
int nrootboundchgsrun
Definition: struct_stat.h:214
SCIP_Real SCIPretransformObj(SCIP *scip, SCIP_Real obj)
Definition: scip_sol.c:1567
int SCIPdivesetGetMaxSolutionDepth(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)
Definition: heur.c:552
void SCIPmessageFPrintInfo(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *formatstr,...)
Definition: message.c:609
int ncomprs
Definition: struct_set.h:127
int SCIPgetNImplications(SCIP *scip)
SCIP_Real SCIPgetAvgInferenceScoreCurrentRun(SCIP *scip)
SCIP_MESSAGEHDLR * messagehdlr
Definition: struct_scip.h:66
SCIP_Longint SCIPgetNBestSolsFound(SCIP *scip)
SCIP_Longint SCIPconshdlrGetNChildren(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4914
#define SCIP_Real
Definition: def.h:177
internal methods for problem statistics
int SCIPgetNPricevarsFound(SCIP *scip)
const char * SCIPbranchruleGetName(SCIP_BRANCHRULE *branchrule)
Definition: branch.c:1962
SCIP_VAR ** vars
Definition: struct_prob.h:55
SCIP_Longint SCIPrelaxGetNCutoffs(SCIP_RELAX *relax)
Definition: relax.c:629
SCIP_PRICER ** pricers
Definition: struct_set.h:71
public methods for relaxation handlers
SCIP_Real SCIPpricerGetSetupTime(SCIP_PRICER *pricer)
Definition: pricer.c:652
SCIP_Longint SCIPvarGetNBranchings(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: var.c:15698
SCIP_Real firstprimaltime
Definition: struct_stat.h:125
public methods for input file readers
SCIP_Longint SCIPconcsolverGetNTighterBnds(SCIP_CONCSOLVER *concsolver)
Definition: concsolver.c:594
SCIP_Longint nrepropboundchgs
Definition: struct_stat.h:90
SCIP_Longint SCIPconflictGetNStrongbranchCalls(SCIP_CONFLICT *conflict)
Definition: conflict.c:9308
SCIP_Longint SCIPconflictGetNInfeasibleLPIterations(SCIP_CONFLICT *conflict)
Definition: conflict.c:8884
int SCIPsepastoreGetNCutsFoundRound(SCIP_SEPASTORE *sepastore)
Definition: sepastore.c:1181
void SCIPprintConstraintTimingStatistics(SCIP *scip, FILE *file)
SCIP_NLP * nlp
Definition: struct_scip.h:83
SCIP_Real firstprimalbound
Definition: struct_stat.h:124
datastructures for collecting primal CIP solutions and primal informations
public methods for message handling
SCIP_Longint ntotalinternalnodes
Definition: struct_stat.h:79
SCIP_Longint SCIPsepaGetNCutsApplied(SCIP_SEPA *sepa)
Definition: sepa.c:932
SCIP_Longint SCIPconshdlrGetNSepaCalls(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4774
#define SCIP_INVALID
Definition: def.h:197
int nnlpis
Definition: struct_set.h:143
int SCIPgetNConflictConssFoundNode(SCIP *scip)
SCIP_Longint SCIPconflictGetNAppliedGlobalLiterals(SCIP_CONFLICT *conflict)
Definition: conflict.c:3797
SCIP_CLOCK * duallptime
Definition: struct_stat.h:156
unsigned int SCIPexprhdlrGetNCreated(SCIP_EXPRHDLR *exprhdlr)
Definition: expr.c:671
int SCIPsolGetDepth(SCIP_SOL *sol)
Definition: sol.c:2594
SCIP_CLOCK * reoptupdatetime
Definition: struct_stat.h:171
#define SCIP_Longint
Definition: def.h:162
SCIP_Longint SCIPheurGetNSolsFound(SCIP_HEUR *heur)
Definition: heur.c:1577
int SCIPconshdlrGetNAggrVars(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4954
SCIP_Real SCIPbendersGetSetupTime(SCIP_BENDERS *benders)
Definition: benders.c:6011
SCIP_Longint nactivatednodes
Definition: struct_stat.h:83
SCIP_Longint nprimallpiterations
Definition: struct_stat.h:56
SCIP_Real SCIPexprhdlrGetReversepropTime(SCIP_EXPRHDLR *exprhdlr)
Definition: expr.c:711
SCIP_Real SCIPvarGetAvgCutoffs(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition: var.c:16264
SCIP_Longint nreprops
Definition: struct_stat.h:89
SCIP_Longint nsbsolsfound
Definition: struct_stat.h:95
int SCIPconshdlrGetNAddConss(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5004
SCIP_TREE * tree
Definition: struct_scip.h:86
int SCIPpricerGetNVarsFound(SCIP_PRICER *pricer)
Definition: pricer.c:642
SCIP_Longint SCIPconcsolverGetNLPIterations(SCIP_CONCSOLVER *concsolver)
Definition: concsolver.c:554
SCIP_CLOCK * nodeactivationtime
Definition: struct_stat.h:167
SCIP_Real SCIPbendersGetTime(SCIP_BENDERS *benders)
Definition: benders.c:6021
SCIP_Longint ndualzeroitlps
Definition: struct_stat.h:188
SCIP_Real SCIPsetEpsilon(SCIP_SET *set)
Definition: set.c:6093
SCIP_Real SCIPhistoryGetAvgInferences(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
Definition: history.c:649
SCIP_Bool SCIPisLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Longint SCIPconflictGetNAppliedConss(SCIP_CONFLICT *conflict)
Definition: conflict.c:3757
SCIP_Real SCIPgetAvgPseudocostScore(SCIP *scip)
SCIP_Longint SCIPgetNLimSolsFound(SCIP *scip)
SCIP_Longint ninternalnodes
Definition: struct_stat.h:74
SCIP_Real SCIPcutselGetTime(SCIP_CUTSEL *cutsel)
Definition: cutsel.c:555
SCIP_Real SCIPprobExternObjval(SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_SET *set, SCIP_Real objval)
Definition: prob.c:2107
#define nnodes
Definition: gastrans.c:65
SCIP_Longint SCIPconflictGetNBoundexceedingLPConflictLiterals(SCIP_CONFLICT *conflict)
Definition: conflict.c:8934
SCIP_Real SCIPtreeGetLowerbound(SCIP_TREE *tree, SCIP_SET *set)
Definition: tree.c:7247
SCIP_Real SCIPstatGetPrimalDualIntegral(SCIP_STAT *stat, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_Bool update)
Definition: stat.c:585
int SCIPgetNPricevarsApplied(SCIP *scip)
int nconshdlrs
Definition: struct_set.h:111
SCIP_Longint SCIPconflictGetNPropReconvergenceLiterals(SCIP_CONFLICT *conflict)
Definition: conflict.c:5777
SCIP_Real SCIPcutpoolGetTime(SCIP_CUTPOOL *cutpool)
Definition: cutpool.c:1086
int SCIPnlpiGetNTermStat(SCIP_NLPI *nlpi, SCIP_NLPTERMSTAT termstatus)
Definition: nlpi.c:784
SCIP_Real SCIPgetAvgPseudocost(SCIP *scip, SCIP_Real solvaldelta)
SCIP_Longint SCIPrelaxGetNAddedConss(SCIP_RELAX *relax)
Definition: relax.c:649
SCIP_Real SCIPgetUpperbound(SCIP *scip)
SCIP_Real SCIPstatGetDualReferenceIntegral(SCIP_STAT *stat, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_Bool update)
Definition: stat.c:543
public methods for separators
#define BMSclearMemoryArray(ptr, num)
Definition: memory.h:123
SCIP_Longint nnodelps
Definition: struct_stat.h:195
public methods for primal heuristics
SCIP_Real SCIPconflictGetPropTime(SCIP_CONFLICT *conflict)
Definition: conflict.c:5717
SCIP_Longint SCIPcutpoolGetMaxNCuts(SCIP_CUTPOOL *cutpool)
Definition: cutpool.c:1076
SCIP_Longint nnodes
Definition: struct_stat.h:73
SCIP_Bool misc_calcintegral
Definition: struct_set.h:395
int SCIPsolGetRunnum(SCIP_SOL *sol)
Definition: sol.c:2574
SCIP_CONCSOLVER ** SCIPgetConcurrentSolvers(SCIP *scip)
Definition: concurrent.c:118
SCIP_Longint SCIPgetNNodeZeroIterationLPs(SCIP *scip)
void SCIPaddNNodes(SCIP *scip, SCIP_Longint nnodes)
SCIP_Longint SCIPconflictGetNDualproofsInfLocal(SCIP_CONFLICT *conflict)
Definition: conflict.c:9248
int SCIPpropGetNDelConss(SCIP_PROP *prop)
Definition: prop.c:1207
#define SCIP_CALL_ABORT(x)
Definition: def.h:363
int SCIPgetNEnabledConss(SCIP *scip)
SCIP_Longint nrelaxsolsfound
Definition: struct_stat.h:93
SCIP_Longint SCIPcutselGetNLocalForcedCuts(SCIP_CUTSEL *cutsel)
Definition: cutsel.c:625
int npresols
Definition: struct_set.h:115
SCIP_LP * lp
Definition: struct_scip.h:82
int firstprimaldepth
Definition: struct_stat.h:263
int SCIPpropGetNAddHoles(SCIP_PROP *prop)
Definition: prop.c:1197
SCIP_Real SCIPheurGetTime(SCIP_HEUR *heur)
Definition: heur.c:1629
SCIP_Longint SCIPgetNNodes(SCIP *scip)
int SCIPtreeGetNNodes(SCIP_TREE *tree)
Definition: tree.c:8249
SCIP_Longint SCIPgetNLPs(SCIP *scip)
static SCIP_RETCODE printProblem(SCIP *scip, SCIP_PROB *prob, FILE *file, const char *extension, SCIP_Bool genericnames)
public methods for cut selectors
SCIP_Longint SCIPgetNInfeasibleLeaves(SCIP *scip)
int SCIPgetVarNStrongbranchs(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:4223
SCIP_Longint SCIPconflictGetNDualproofsBndGlobal(SCIP_CONFLICT *conflict)
Definition: conflict.c:9278
SCIP_Real SCIPreoptGetSavingtime(SCIP_REOPT *reopt)
Definition: reopt.c:7656
SCIP_Longint nlimsolsfound
Definition: struct_primal.h:40
SCIP_Real SCIPgetAvgConflictScoreCurrentRun(SCIP *scip)
void SCIPprintOrigProblemStatistics(SCIP *scip, FILE *file)
SCIP_Longint SCIPgetNFeasibleLeaves(SCIP *scip)
int SCIPpresolGetNAddConss(SCIP_PRESOL *presol)
Definition: presol.c:768
datastructures for global SCIP settings
int SCIPconshdlrGetNAddHoles(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4984
SCIP_Real SCIPpropGetTime(SCIP_PROP *prop)
Definition: prop.c:1047
int SCIPpresolGetNChgBds(SCIP_PRESOL *presol)
Definition: presol.c:738
SCIP_Bool time_nlpieval
Definition: struct_set.h:589
SCIP_Longint SCIPgetNRootStrongbranchs(SCIP *scip)
SCIP_Bool SCIPpropDoesPresolve(SCIP_PROP *prop)
Definition: prop.c:1277
SCIP_Real SCIPgetFirstLPTime(SCIP *scip)
Definition: scip_timing.c:459
SCIP_Real SCIPconshdlrGetSetupTime(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4674
int SCIPgetNTables(SCIP *scip)
Definition: scip_table.c:109
int SCIPdivesetGetMaxDepth(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)
Definition: heur.c:513
SCIP_Longint ninitlps
Definition: struct_stat.h:197
SCIP_Real SCIPgetAvgInferenceScore(SCIP *scip)
int SCIPreoptGetNTotalRestartsLocal(SCIP_REOPT *reopt)
Definition: reopt.c:4972
SCIP_Real SCIPvarGetPseudocostVariance(SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun)
Definition: var.c:14691
int SCIPgetNSepaRounds(SCIP *scip)
SCIP_Longint ndelayedcutoffs
Definition: struct_stat.h:88
void SCIPsetSortBranchrulesName(SCIP_SET *set)
Definition: set.c:4941
SCIP_Real SCIPgetPseudocostCount(SCIP *scip, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun)
SCIP_CLOCK * lpsoltime
Definition: struct_stat.h:163
SCIP_Real SCIPcomputeGap(SCIP_Real eps, SCIP_Real inf, SCIP_Real primalbound, SCIP_Real dualbound)
Definition: misc.c:11081
public methods for propagators
SCIP_Real SCIPgetAvgInferences(SCIP *scip, SCIP_BRANCHDIR dir)
internal methods for displaying runtime statistics
int nimplications
Definition: struct_stat.h:232
void SCIPsetSortPricersName(SCIP_SET *set)
Definition: set.c:3779
const char * SCIPdivesetGetName(SCIP_DIVESET *diveset)
Definition: heur.c:434
int SCIPreoptGetNTotalPrunedNodes(SCIP_REOPT *reopt)
Definition: reopt.c:5032
SCIP_Longint ndivinglpiterations
Definition: struct_stat.h:65
int SCIPpricestoreGetNProbPricings(SCIP_PRICESTORE *pricestore)
Definition: pricestore.c:632
memory allocation routines