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