Scippy

SCIP

Solving Constraint Integer Programs

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