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 2002-2022 Zuse Institute Berlin */
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 /** gets deterministic time number of LPs solved so far
1624  *
1625  * @return the total number of LPs solved so far
1626  *
1627  * @pre This method can be called if SCIP is in one of the following stages:
1628  * - \ref SCIP_STAGE_PRESOLVED
1629  * - \ref SCIP_STAGE_SOLVING
1630  * - \ref SCIP_STAGE_SOLVED
1631  */
1632 SCIP_EXPORT
1633 SCIP_Real SCIPgetDeterministicTime(
1634  SCIP* scip /**< SCIP data structure */
1635  );
1636 
1637 /** outputs original problem to file stream
1638  *
1639  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1640  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1641  *
1642  * @pre This method can be called if SCIP is in one of the following stages:
1643  * - \ref SCIP_STAGE_PROBLEM
1644  * - \ref SCIP_STAGE_TRANSFORMING
1645  * - \ref SCIP_STAGE_TRANSFORMED
1646  * - \ref SCIP_STAGE_INITPRESOLVE
1647  * - \ref SCIP_STAGE_PRESOLVING
1648  * - \ref SCIP_STAGE_EXITPRESOLVE
1649  * - \ref SCIP_STAGE_PRESOLVED
1650  * - \ref SCIP_STAGE_INITSOLVE
1651  * - \ref SCIP_STAGE_SOLVING
1652  * - \ref SCIP_STAGE_SOLVED
1653  * - \ref SCIP_STAGE_EXITSOLVE
1654  * - \ref SCIP_STAGE_FREETRANS
1655  */
1656 SCIP_EXPORT
1657 SCIP_RETCODE SCIPprintOrigProblem(
1658  SCIP* scip, /**< SCIP data structure */
1659  FILE* file, /**< output file (or NULL for standard output) */
1660  const char* extension, /**< file format (or NULL for default CIP format)*/
1661  SCIP_Bool genericnames /**< using generic variable and constraint names? */
1662  );
1663 
1664 /** outputs transformed problem of the current node 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_TRANSFORMED
1671  * - \ref SCIP_STAGE_INITPRESOLVE
1672  * - \ref SCIP_STAGE_PRESOLVING
1673  * - \ref SCIP_STAGE_EXITPRESOLVE
1674  * - \ref SCIP_STAGE_PRESOLVED
1675  * - \ref SCIP_STAGE_INITSOLVE
1676  * - \ref SCIP_STAGE_SOLVING
1677  * - \ref SCIP_STAGE_SOLVED
1678  * - \ref SCIP_STAGE_EXITSOLVE
1679  * - \ref SCIP_STAGE_FREETRANS
1680  */
1681 SCIP_EXPORT
1682 SCIP_RETCODE SCIPprintTransProblem(
1683  SCIP* scip, /**< SCIP data structure */
1684  FILE* file, /**< output file (or NULL for standard output) */
1685  const char* extension, /**< file format (or NULL for default CIP format)*/
1686  SCIP_Bool genericnames /**< using generic variable and constraint names? */
1687  );
1688 
1689 /** outputs status statistics
1690  *
1691  * @note If limits have been changed between the solution and the call to this function, the status is recomputed and
1692  * thus may to correspond to the original status.
1693  *
1694  * @pre This method can be called if SCIP is in one of the following stages:
1695  * - \ref SCIP_STAGE_INIT
1696  * - \ref SCIP_STAGE_PROBLEM
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_SOLVING
1703  * - \ref SCIP_STAGE_SOLVED
1704  */
1705 SCIP_EXPORT
1706 void SCIPprintStatusStatistics(
1707  SCIP* scip, /**< SCIP data structure */
1708  FILE* file /**< output file */
1709  );
1710 
1711 /** outputs timing statistics
1712  *
1713  * @pre This method can be called if SCIP is in one of the following stages:
1714  * - \ref SCIP_STAGE_PROBLEM
1715  * - \ref SCIP_STAGE_TRANSFORMED
1716  * - \ref SCIP_STAGE_INITPRESOLVE
1717  * - \ref SCIP_STAGE_PRESOLVING
1718  * - \ref SCIP_STAGE_EXITPRESOLVE
1719  * - \ref SCIP_STAGE_PRESOLVED
1720  * - \ref SCIP_STAGE_SOLVING
1721  * - \ref SCIP_STAGE_SOLVED
1722  */
1723 SCIP_EXPORT
1724 void SCIPprintTimingStatistics(
1725  SCIP* scip, /**< SCIP data structure */
1726  FILE* file /**< output file */
1727  );
1728 
1729 /** outputs statistics for original problem
1730  *
1731  * @pre This method can be called if SCIP is in one of the following stages:
1732  * - \ref SCIP_STAGE_PROBLEM
1733  * - \ref SCIP_STAGE_TRANSFORMED
1734  * - \ref SCIP_STAGE_INITPRESOLVE
1735  * - \ref SCIP_STAGE_PRESOLVING
1736  * - \ref SCIP_STAGE_EXITPRESOLVE
1737  * - \ref SCIP_STAGE_PRESOLVED
1738  * - \ref SCIP_STAGE_SOLVING
1739  * - \ref SCIP_STAGE_SOLVED
1740  */
1741 SCIP_EXPORT
1742 void SCIPprintOrigProblemStatistics(
1743  SCIP* scip, /**< SCIP data structure */
1744  FILE* file /**< output file (or NULL for standard output) */
1745  );
1746 
1747 /** outputs statistics for transformed problem
1748  *
1749  * @pre This method can be called if SCIP is in one of the following stages:
1750  * - \ref SCIP_STAGE_PROBLEM
1751  * - \ref SCIP_STAGE_TRANSFORMED
1752  * - \ref SCIP_STAGE_INITPRESOLVE
1753  * - \ref SCIP_STAGE_PRESOLVING
1754  * - \ref SCIP_STAGE_EXITPRESOLVE
1755  * - \ref SCIP_STAGE_PRESOLVED
1756  * - \ref SCIP_STAGE_SOLVING
1757  * - \ref SCIP_STAGE_SOLVED
1758  */
1759 SCIP_EXPORT
1760 void SCIPprintTransProblemStatistics(
1761  SCIP* scip, /**< SCIP data structure */
1762  FILE* file /**< output file */
1763  );
1764 
1765 /** outputs presolver statistics
1766  *
1767  * @pre This method can be called if SCIP is in one of the following stages:
1768  * - \ref SCIP_STAGE_TRANSFORMED
1769  * - \ref SCIP_STAGE_INITPRESOLVE
1770  * - \ref SCIP_STAGE_PRESOLVING
1771  * - \ref SCIP_STAGE_EXITPRESOLVE
1772  * - \ref SCIP_STAGE_PRESOLVED
1773  * - \ref SCIP_STAGE_SOLVING
1774  * - \ref SCIP_STAGE_SOLVED
1775  */
1776 SCIP_EXPORT
1777 void SCIPprintPresolverStatistics(
1778  SCIP* scip, /**< SCIP data structure */
1779  FILE* file /**< output file */
1780  );
1781 
1782 /** outputs constraint statistics
1783  *
1784  * @pre This method can be called if SCIP is in one of the following stages:
1785  * - \ref SCIP_STAGE_TRANSFORMED
1786  * - \ref SCIP_STAGE_INITPRESOLVE
1787  * - \ref SCIP_STAGE_PRESOLVING
1788  * - \ref SCIP_STAGE_EXITPRESOLVE
1789  * - \ref SCIP_STAGE_PRESOLVED
1790  * - \ref SCIP_STAGE_SOLVING
1791  * - \ref SCIP_STAGE_SOLVED
1792  */
1793 SCIP_EXPORT
1794 void SCIPprintConstraintStatistics(
1795  SCIP* scip, /**< SCIP data structure */
1796  FILE* file /**< output file */
1797  );
1798 
1799 /** outputs constraint timing statistics
1800  *
1801  * @pre This method can be called if SCIP is in one of the following stages:
1802  * - \ref SCIP_STAGE_TRANSFORMED
1803  * - \ref SCIP_STAGE_INITPRESOLVE
1804  * - \ref SCIP_STAGE_PRESOLVING
1805  * - \ref SCIP_STAGE_EXITPRESOLVE
1806  * - \ref SCIP_STAGE_PRESOLVED
1807  * - \ref SCIP_STAGE_SOLVING
1808  * - \ref SCIP_STAGE_SOLVED
1809  */
1810 SCIP_EXPORT
1811 void SCIPprintConstraintTimingStatistics(
1812  SCIP* scip, /**< SCIP data structure */
1813  FILE* file /**< output file */
1814  );
1815 
1816 /** outputs propagator statistics
1817  *
1818  * @pre This method can be called if SCIP is in one of the following stages:
1819  * - \ref SCIP_STAGE_TRANSFORMED
1820  * - \ref SCIP_STAGE_INITPRESOLVE
1821  * - \ref SCIP_STAGE_PRESOLVING
1822  * - \ref SCIP_STAGE_EXITPRESOLVE
1823  * - \ref SCIP_STAGE_PRESOLVED
1824  * - \ref SCIP_STAGE_SOLVING
1825  * - \ref SCIP_STAGE_SOLVED
1826  */
1827 SCIP_EXPORT
1828 void SCIPprintPropagatorStatistics(
1829  SCIP* scip, /**< SCIP data structure */
1830  FILE* file /**< output file */
1831  );
1832 
1833 /** outputs conflict statistics
1834  *
1835  * @pre This method can be called if SCIP is in one of the following stages:
1836  * - \ref SCIP_STAGE_TRANSFORMED
1837  * - \ref SCIP_STAGE_INITPRESOLVE
1838  * - \ref SCIP_STAGE_PRESOLVING
1839  * - \ref SCIP_STAGE_EXITPRESOLVE
1840  * - \ref SCIP_STAGE_PRESOLVED
1841  * - \ref SCIP_STAGE_SOLVING
1842  * - \ref SCIP_STAGE_SOLVED
1843  */
1844 SCIP_EXPORT
1845 void SCIPprintConflictStatistics(
1846  SCIP* scip, /**< SCIP data structure */
1847  FILE* file /**< output file */
1848  );
1849 
1850 /** outputs separator statistics
1851  *
1852  * Columns:
1853  * - RootCalls: The number of calls that happened at the root.
1854  * - FoundCuts: The total number of cuts generated by the separators.
1855  * Note: Cutpool-FoundCuts \f$= \sum_{i=1}^nsepas ( Foundcuts_i - DirectAdd_i )\f$.
1856  * - ViaPoolAdd: The total number of cuts added to the sepastore from the cutpool.
1857  * - DirectAdd: The total number of cuts added directly to the sepastore from the separator.
1858  * - Applied: The sum of all cuts from the separator that were applied to the LP.
1859  * - ViaPoolApp: The number of cuts that entered the sepastore from the cutpool that were applied to the LP.
1860  * - DirectApp: The number of cuts that entered the sepastore directly and were applied to the LP.
1861  *
1862  * The number of cuts ViaPoolAdd + Directly should be equal to the number of cuts Filtered + Forced + Selected in the
1863  * cutselector statistics.
1864  *
1865  * @note The following edge case may lead to over or undercounting of statistics: When SCIPapplyCutsProbing() is
1866  * called, cuts are counted for the cut selection statistics, but not for the separator statistics. This
1867  * happens, e.g., in the default plugin prop_obbt.c.
1868  *
1869  * @pre This method can be called if SCIP is in one of the following stages:
1870  * - \ref SCIP_STAGE_SOLVING
1871  * - \ref SCIP_STAGE_SOLVED
1872  */
1873 SCIP_EXPORT
1874 void SCIPprintSeparatorStatistics(
1875  SCIP* scip, /**< SCIP data structure */
1876  FILE* file /**< output file */
1877  );
1878 
1879 /** outputs cutselector statistics
1880  *
1881  * @pre This method can be called if SCIP is in one of the following stages:
1882  * - \ref SCIP_STAGE_SOLVING
1883  * - \ref SCIP_STAGE_SOLVED
1884  */
1885 SCIP_EXPORT
1886 void SCIPprintCutselectorStatistics(
1887  SCIP* scip, /**< SCIP data structure */
1888  FILE* file /**< output file */
1889  );
1890 
1891 /** outputs pricer statistics
1892  *
1893  * @pre This method can be called if SCIP is in one of the following stages:
1894  * - \ref SCIP_STAGE_SOLVING
1895  * - \ref SCIP_STAGE_SOLVED
1896  */
1897 SCIP_EXPORT
1898 void SCIPprintPricerStatistics(
1899  SCIP* scip, /**< SCIP data structure */
1900  FILE* file /**< output file */
1901  );
1902 
1903 /** outputs branching rule statistics
1904  *
1905  * @pre This method can be called if SCIP is in one of the following stages:
1906  * - \ref SCIP_STAGE_SOLVING
1907  * - \ref SCIP_STAGE_SOLVED
1908  */
1909 SCIP_EXPORT
1910 void SCIPprintBranchruleStatistics(
1911  SCIP* scip, /**< SCIP data structure */
1912  FILE* file /**< output file */
1913  );
1914 
1915 /** outputs heuristics statistics
1916  *
1917  * @pre This method can be called if SCIP is in one of the following stages:
1918  * - \ref SCIP_STAGE_PRESOLVING
1919  * - \ref SCIP_STAGE_EXITPRESOLVE
1920  * - \ref SCIP_STAGE_PRESOLVED
1921  * - \ref SCIP_STAGE_SOLVING
1922  * - \ref SCIP_STAGE_SOLVED
1923  */
1924 SCIP_EXPORT
1925 void SCIPprintHeuristicStatistics(
1926  SCIP* scip, /**< SCIP data structure */
1927  FILE* file /**< output file */
1928  );
1929 
1930 /** outputs compression statistics
1931  *
1932  * @pre This method can be called if SCIP is in one of the following stages:
1933  * - \ref SCIP_STAGE_PRESOLVING
1934  * - \ref SCIP_STAGE_EXITPRESOLVE
1935  * - \ref SCIP_STAGE_PRESOLVED
1936  * - \ref SCIP_STAGE_SOLVING
1937  * - \ref SCIP_STAGE_SOLVED
1938  */
1939 SCIP_EXPORT
1940 void SCIPprintCompressionStatistics(
1941  SCIP* scip, /**< SCIP data structure */
1942  FILE* file /**< output file */
1943  );
1944 
1945 /** outputs LP statistics
1946  *
1947  * @pre This method can be called if SCIP is in one of the following stages:
1948  * - \ref SCIP_STAGE_SOLVING
1949  * - \ref SCIP_STAGE_SOLVED
1950  */
1951 SCIP_EXPORT
1952 void SCIPprintLPStatistics(
1953  SCIP* scip, /**< SCIP data structure */
1954  FILE* file /**< output file */
1955  );
1956 
1957 /** outputs NLP statistics
1958  *
1959  * @pre This method can be called if SCIP is in one of the following stages:
1960  * - \ref SCIP_STAGE_SOLVING
1961  * - \ref SCIP_STAGE_SOLVED
1962  */
1963 SCIP_EXPORT
1964 void SCIPprintNLPStatistics(
1965  SCIP* scip, /**< SCIP data structure */
1966  FILE* file /**< output file */
1967  );
1968 
1969 /** outputs relaxator statistics
1970  *
1971  * @pre This method can be called if SCIP is in one of the following stages:
1972  * - \ref SCIP_STAGE_SOLVING
1973  * - \ref SCIP_STAGE_SOLVED
1974  */
1975 SCIP_EXPORT
1976 void SCIPprintRelaxatorStatistics(
1977  SCIP* scip, /**< SCIP data structure */
1978  FILE* file /**< output file */
1979  );
1980 
1981 /** outputs tree statistics
1982  *
1983  * @pre This method can be called if SCIP is in one of the following stages:
1984  * - \ref SCIP_STAGE_SOLVING
1985  * - \ref SCIP_STAGE_SOLVED
1986  */
1987 SCIP_EXPORT
1988 void SCIPprintTreeStatistics(
1989  SCIP* scip, /**< SCIP data structure */
1990  FILE* file /**< output file */
1991  );
1992 
1993 /** outputs root statistics
1994  *
1995  * @pre This method can be called if SCIP is in one of the following stages:
1996  * - \ref SCIP_STAGE_SOLVING
1997  * - \ref SCIP_STAGE_SOLVED
1998  */
1999 SCIP_EXPORT
2000 void SCIPprintRootStatistics(
2001  SCIP* scip, /**< SCIP data structure */
2002  FILE* file /**< output file */
2003  );
2004 
2005 /** outputs solution statistics
2006  *
2007  * @pre This method can be called if SCIP is in one of the following stages:
2008  * - \ref SCIP_STAGE_PRESOLVING
2009  * - \ref SCIP_STAGE_EXITPRESOLVE
2010  * - \ref SCIP_STAGE_PRESOLVED
2011  * - \ref SCIP_STAGE_SOLVING
2012  * - \ref SCIP_STAGE_SOLVED
2013  */
2014 SCIP_EXPORT
2015 void SCIPprintSolutionStatistics(
2016  SCIP* scip, /**< SCIP data structure */
2017  FILE* file /**< output file */
2018  );
2019 
2020 /** outputs concurrent solver statistics
2021  *
2022  * @pre This method can be called if SCIP is in one of the following stages:
2023  * - \ref SCIP_STAGE_TRANSFORMED
2024  * - \ref SCIP_STAGE_INITPRESOLVE
2025  * - \ref SCIP_STAGE_PRESOLVING
2026  * - \ref SCIP_STAGE_EXITPRESOLVE
2027  * - \ref SCIP_STAGE_PRESOLVED
2028  * - \ref SCIP_STAGE_SOLVING
2029  * - \ref SCIP_STAGE_SOLVED
2030  */
2031 SCIP_EXPORT
2032 void SCIPprintConcsolverStatistics(
2033  SCIP* scip, /**< SCIP data structure */
2034  FILE* file /**< output file */
2035  );
2036 
2037 /** outputs Benders' decomposition statistics
2038  *
2039  * @pre This method can be called if SCIP is in one of the following stages:
2040  * - \ref SCIP_STAGE_SOLVING
2041  * - \ref SCIP_STAGE_SOLVED
2042  */
2043 SCIP_EXPORT
2044 void SCIPprintBendersStatistics(
2045  SCIP* scip, /**< SCIP data structure */
2046  FILE* file /**< output file */
2047  );
2048 
2049 /** outputs expression handler statistics
2050  *
2051  * @pre This method can be called if SCIP is in one of the following stages:
2052  * - \ref SCIP_STAGE_PROBLEM
2053  * - \ref SCIP_STAGE_TRANSFORMED
2054  * - \ref SCIP_STAGE_INITPRESOLVE
2055  * - \ref SCIP_STAGE_PRESOLVING
2056  * - \ref SCIP_STAGE_EXITPRESOLVE
2057  * - \ref SCIP_STAGE_PRESOLVED
2058  * - \ref SCIP_STAGE_SOLVING
2059  * - \ref SCIP_STAGE_SOLVED
2060  */
2061 SCIP_EXPORT
2062 void SCIPprintExpressionHandlerStatistics(
2063  SCIP* scip, /**< SCIP data structure */
2064  FILE* file /**< output file */
2065  );
2066 
2067 /** outputs NLPI statistics
2068  *
2069  * @pre This method can be called if SCIP is in one of the following stages:
2070  * - \ref SCIP_STAGE_PROBLEM
2071  * - \ref SCIP_STAGE_TRANSFORMED
2072  * - \ref SCIP_STAGE_INITPRESOLVE
2073  * - \ref SCIP_STAGE_PRESOLVING
2074  * - \ref SCIP_STAGE_EXITPRESOLVE
2075  * - \ref SCIP_STAGE_PRESOLVED
2076  * - \ref SCIP_STAGE_SOLVING
2077  * - \ref SCIP_STAGE_SOLVED
2078  */
2079 SCIP_EXPORT
2080 void SCIPprintNLPIStatistics(
2081  SCIP* scip, /**< SCIP data structure */
2082  FILE* file /**< output file */
2083  );
2084 
2085 /** outputs solving statistics
2086  *
2087  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2088  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2089  *
2090  * @note If limits have been changed between the solution and the call to this function, the status is recomputed and
2091  * thus may to correspond to the original status.
2092  *
2093  * @pre This method can be called if SCIP is in one of the following stages:
2094  * - \ref SCIP_STAGE_INIT
2095  * - \ref SCIP_STAGE_PROBLEM
2096  * - \ref SCIP_STAGE_TRANSFORMED
2097  * - \ref SCIP_STAGE_INITPRESOLVE
2098  * - \ref SCIP_STAGE_PRESOLVING
2099  * - \ref SCIP_STAGE_EXITPRESOLVE
2100  * - \ref SCIP_STAGE_PRESOLVED
2101  * - \ref SCIP_STAGE_SOLVING
2102  * - \ref SCIP_STAGE_SOLVED
2103  */
2104 SCIP_EXPORT
2105 SCIP_RETCODE SCIPprintStatistics(
2106  SCIP* scip, /**< SCIP data structure */
2107  FILE* file /**< output file (or NULL for standard output) */
2108  );
2109 
2110 /** outputs reoptimization statistics
2111  *
2112  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2113  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2114  *
2115  * @pre This method can be called if SCIP is in one of the following stages:
2116  * - \ref SCIP_STAGE_INIT
2117  * - \ref SCIP_STAGE_PROBLEM
2118  * - \ref SCIP_STAGE_TRANSFORMED
2119  * - \ref SCIP_STAGE_INITPRESOLVE
2120  * - \ref SCIP_STAGE_PRESOLVING
2121  * - \ref SCIP_STAGE_EXITPRESOLVE
2122  * - \ref SCIP_STAGE_PRESOLVED
2123  * - \ref SCIP_STAGE_SOLVING
2124  * - \ref SCIP_STAGE_SOLVED
2125  */
2126 SCIP_EXPORT
2127 SCIP_RETCODE SCIPprintReoptStatistics(
2128  SCIP* scip, /**< SCIP data structure */
2129  FILE* file /**< output file (or NULL for standard output) */
2130  );
2131 
2132 /** outputs history statistics about branchings on variables
2133  *
2134  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2135  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2136  *
2137  * @pre This method can be called if SCIP is in one of the following stages:
2138  * - \ref SCIP_STAGE_INIT
2139  * - \ref SCIP_STAGE_PROBLEM
2140  * - \ref SCIP_STAGE_TRANSFORMED
2141  * - \ref SCIP_STAGE_INITPRESOLVE
2142  * - \ref SCIP_STAGE_PRESOLVING
2143  * - \ref SCIP_STAGE_EXITPRESOLVE
2144  * - \ref SCIP_STAGE_PRESOLVED
2145  * - \ref SCIP_STAGE_SOLVING
2146  * - \ref SCIP_STAGE_SOLVED
2147  */
2148 SCIP_EXPORT
2149 SCIP_RETCODE SCIPprintBranchingStatistics(
2150  SCIP* scip, /**< SCIP data structure */
2151  FILE* file /**< output file (or NULL for standard output) */
2152  );
2153 
2154 /** outputs node information display line
2155  *
2156  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2157  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2158  *
2159  * @pre This method can be called if SCIP is in one of the following stages:
2160  * - \ref SCIP_STAGE_SOLVING
2161  */
2162 SCIP_EXPORT
2163 SCIP_RETCODE SCIPprintDisplayLine(
2164  SCIP* scip, /**< SCIP data structure */
2165  FILE* file, /**< output file (or NULL for standard output) */
2166  SCIP_VERBLEVEL verblevel, /**< minimal verbosity level to actually display the information line */
2167  SCIP_Bool endline /**< should the line be terminated with a newline symbol? */
2168  );
2169 
2170 /** gets total number of implications between variables that are stored in the implication graph
2171  *
2172  * @return the total number of implications between variables that are stored in the implication graph
2173  *
2174  * @pre This method can be called if SCIP is in one of the following stages:
2175  * - \ref SCIP_STAGE_INITPRESOLVE
2176  * - \ref SCIP_STAGE_PRESOLVING
2177  * - \ref SCIP_STAGE_EXITPRESOLVE
2178  * - \ref SCIP_STAGE_PRESOLVED
2179  * - \ref SCIP_STAGE_INITSOLVE
2180  * - \ref SCIP_STAGE_SOLVING
2181  * - \ref SCIP_STAGE_SOLVED
2182  */
2183 SCIP_EXPORT
2184 int SCIPgetNImplications(
2185  SCIP* scip /**< SCIP data structure */
2186  );
2187 
2188 /** stores conflict graph of binary variables' implications into a file, which can be used as input for the DOT tool
2189  *
2190  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2191  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2192  *
2193  * @pre This method can be called if SCIP is in one of the following stages:
2194  * - \ref SCIP_STAGE_TRANSFORMED
2195  * - \ref SCIP_STAGE_INITPRESOLVE
2196  * - \ref SCIP_STAGE_PRESOLVING
2197  * - \ref SCIP_STAGE_EXITPRESOLVE
2198  * - \ref SCIP_STAGE_PRESOLVED
2199  * - \ref SCIP_STAGE_INITSOLVE
2200  * - \ref SCIP_STAGE_SOLVING
2201  * - \ref SCIP_STAGE_SOLVED
2202  * - \ref SCIP_STAGE_EXITSOLVE
2203  *
2204  * @deprecated because binary implications are now stored as cliques
2205  */
2206 SCIP_EXPORT
2207 SCIP_RETCODE SCIPwriteImplicationConflictGraph(
2208  SCIP* scip, /**< SCIP data structure */
2209  const char* filename /**< file name, or NULL for stdout */
2210  );
2211 
2212 
2213 /** update statistical information when a new solution was found */
2214 SCIP_EXPORT
2215 void SCIPstoreSolutionGap(
2216  SCIP* scip /**< SCIP data structure */
2217  );
2218 
2219 /**@} */
2220 
2221 #ifdef __cplusplus
2222 }
2223 #endif
2224 
2225 #endif
SCIPprintReoptStatistics
SCIP_RETCODE SCIPprintReoptStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:4189
SCIPgetAvgPseudocostCountCurrentRun
SCIP_Real SCIPgetAvgPseudocostCountCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)
Definition: scip_solvingstats.c:1870
SCIPgetFirstPrimalBound
SCIP_Real SCIPgetFirstPrimalBound(SCIP *scip)
Definition: scip_solvingstats.c:1509
SCIPgetNRootLPIterations
SCIP_Longint SCIPgetNRootLPIterations(SCIP *scip)
Definition: scip_solvingstats.c:491
SCIPprintSeparatorStatistics
void SCIPprintSeparatorStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:2956
SCIPgetAvgPseudocostScoreCurrentRun
SCIP_Real SCIPgetAvgPseudocostScoreCurrentRun(SCIP *scip)
Definition: scip_solvingstats.c:1963
SCIPprintConstraintStatistics
void SCIPprintConstraintStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:2624
SCIPgetFirstLPLowerboundRoot
SCIP_Real SCIPgetFirstLPLowerboundRoot(SCIP *scip)
Definition: scip_solvingstats.c:1496
SCIPgetNLPIterations
SCIP_Longint SCIPgetNLPIterations(SCIP *scip)
Definition: scip_solvingstats.c:447
SCIPgetDualboundRoot
SCIP_Real SCIPgetDualboundRoot(SCIP *scip)
Definition: scip_solvingstats.c:1427
SCIPgetCutoffbound
SCIP_Real SCIPgetCutoffbound(SCIP *scip)
Definition: scip_solvingstats.c:1585
SCIPgetPrimalbound
SCIP_Real SCIPgetPrimalbound(SCIP *scip)
Definition: scip_solvingstats.c:1531
SCIPupdateCutoffbound
SCIP_RETCODE SCIPupdateCutoffbound(SCIP *scip, SCIP_Real cutoffbound)
Definition: scip_solvingstats.c:1613
SCIPgetNSolsFound
SCIP_Longint SCIPgetNSolsFound(SCIP *scip)
Definition: scip_solvingstats.c:1740
SCIPgetNBarrierLPs
SCIP_Longint SCIPgetNBarrierLPs(SCIP *scip)
Definition: scip_solvingstats.c:600
SCIPprintConcsolverStatistics
void SCIPprintConcsolverStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:3750
SCIPgetAvgCutoffScoreCurrentRun
SCIP_Real SCIPgetAvgCutoffScoreCurrentRun(SCIP *scip)
Definition: scip_solvingstats.c:2231
SCIPgetNConflictDualproofsApplied
SCIP_Longint SCIPgetNConflictDualproofsApplied(SCIP *scip)
Definition: scip_solvingstats.c:1177
SCIPgetAvgConflictScore
SCIP_Real SCIPgetAvgConflictScore(SCIP *scip)
Definition: scip_solvingstats.c:1986
SCIPprintTransProblem
SCIP_RETCODE SCIPprintTransProblem(SCIP *scip, FILE *file, const char *extension, SCIP_Bool genericnames)
Definition: scip_solvingstats.c:2383
SCIPgetNDualLPs
SCIP_Longint SCIPgetNDualLPs(SCIP *scip)
Definition: scip_solvingstats.c:564
SCIPgetMaxDepth
int SCIPgetMaxDepth(SCIP *scip)
Definition: scip_solvingstats.c:1202
SCIPprintStatusStatistics
void SCIPprintStatusStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:2426
SCIPprintDisplayLine
SCIP_RETCODE SCIPprintDisplayLine(SCIP *scip, FILE *file, SCIP_VERBLEVEL verblevel, SCIP_Bool endline)
Definition: scip_solvingstats.c:4385
SCIPgetNPrimalResolveLPs
SCIP_Longint SCIPgetNPrimalResolveLPs(SCIP *scip)
Definition: scip_solvingstats.c:674
SCIPprintBendersStatistics
void SCIPprintBendersStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:3794
SCIPprintTransProblemStatistics
void SCIPprintTransProblemStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:2479
SCIPprintTimingStatistics
void SCIPprintTimingStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:3921
SCIPgetDeterministicTime
SCIP_Real SCIPgetDeterministicTime(SCIP *scip)
Definition: scip_solvingstats.c:2256
SCIPgetNStrongbranchs
SCIP_Longint SCIPgetNStrongbranchs(SCIP *scip)
Definition: scip_solvingstats.c:876
SCIP_RETCODE
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
SCIPprintHeuristicStatistics
void SCIPprintHeuristicStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:3166
SCIPgetAvgLowerbound
SCIP_Real SCIPgetAvgLowerbound(SCIP *scip)
Definition: scip_solvingstats.c:1324
SCIPgetNRootFirstLPIterations
SCIP_Longint SCIPgetNRootFirstLPIterations(SCIP *scip)
Definition: scip_solvingstats.c:510
SCIP_VERBLEVEL
enum SCIP_VerbLevel SCIP_VERBLEVEL
Definition: type_message.h:57
SCIPgetNNZs
SCIP_Longint SCIPgetNNZs(SCIP *scip)
Definition: scip_solvingstats.c:473
SCIPgetNRootStrongbranchLPIterations
SCIP_Longint SCIPgetNRootStrongbranchLPIterations(SCIP *scip)
Definition: scip_solvingstats.c:930
SCIPgetNActiveConss
int SCIPgetNActiveConss(SCIP *scip)
Definition: scip_solvingstats.c:1270
SCIPgetNBacktracks
SCIP_Longint SCIPgetNBacktracks(SCIP *scip)
Definition: scip_solvingstats.c:1250
SCIPgetNDivingLPIterations
SCIP_Longint SCIPgetNDivingLPIterations(SCIP *scip)
Definition: scip_solvingstats.c:858
SCIPprintPresolverStatistics
void SCIPprintPresolverStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:2506
type_retcode.h
type definitions for return codes for SCIP methods
SCIPgetNCutsFoundRound
int SCIPgetNCutsFoundRound(SCIP *scip)
Definition: scip_solvingstats.c:1052
SCIPgetNRootboundChgsRun
int SCIPgetNRootboundChgsRun(SCIP *scip)
Definition: scip_solvingstats.c:374
SCIPprintBranchruleStatistics
void SCIPprintBranchruleStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:3123
SCIPprintStatistics
SCIP_RETCODE SCIPprintStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:4136
SCIPgetAvgCutoffs
SCIP_Real SCIPgetAvgCutoffs(SCIP *scip, SCIP_BRANCHDIR dir)
Definition: scip_solvingstats.c:2170
SCIPgetLowerboundRoot
SCIP_Real SCIPgetLowerboundRoot(SCIP *scip)
Definition: scip_solvingstats.c:1451
SCIPprintBranchingStatistics
SCIP_RETCODE SCIPprintBranchingStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:4270
SCIPgetNDualResolveLPIterations
SCIP_Longint SCIPgetNDualResolveLPIterations(SCIP *scip)
Definition: scip_solvingstats.c:732
SCIP_BRANCHDIR
enum SCIP_BranchDir SCIP_BRANCHDIR
Definition: type_history.h:48
SCIPgetFirstLPDualboundRoot
SCIP_Real SCIPgetFirstLPDualboundRoot(SCIP *scip)
Definition: scip_solvingstats.c:1475
SCIPgetNCutsApplied
int SCIPgetNCutsApplied(SCIP *scip)
Definition: scip_solvingstats.c:1070
SCIPgetNNodeLPs
SCIP_Longint SCIPgetNNodeLPs(SCIP *scip)
Definition: scip_solvingstats.c:750
SCIPstoreSolutionGap
void SCIPstoreSolutionGap(SCIP *scip)
Definition: scip_solvingstats.c:4454
SCIPgetNCutsFound
int SCIPgetNCutsFound(SCIP *scip)
Definition: scip_solvingstats.c:1034
SCIPgetDualbound
SCIP_Real SCIPgetDualbound(SCIP *scip)
Definition: scip_solvingstats.c:1348
type_scip.h
type definitions for SCIP&#39;s main datastructure
SCIPgetTransGap
SCIP_Real SCIPgetTransGap(SCIP *scip)
Definition: scip_solvingstats.c:1702
SCIPgetNResolveLPIterations
SCIP_Longint SCIPgetNResolveLPIterations(SCIP *scip)
Definition: scip_solvingstats.c:656
SCIPprintConflictStatistics
void SCIPprintConflictStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:2807
SCIPprintCompressionStatistics
void SCIPprintCompressionStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:3277
SCIPgetNRootboundChgs
int SCIPgetNRootboundChgs(SCIP *scip)
Definition: scip_solvingstats.c:347
SCIPprintLPStatistics
void SCIPprintLPStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:3314
SCIPgetNDelayedCutoffs
SCIP_Longint SCIPgetNDelayedCutoffs(SCIP *scip)
Definition: scip_solvingstats.c:401
SCIPprintOrigProblem
SCIP_RETCODE SCIPprintOrigProblem(SCIP *scip, FILE *file, const char *extension, SCIP_Bool genericnames)
Definition: scip_solvingstats.c:2339
SCIPprintPropagatorStatistics
void SCIPprintPropagatorStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:2744
SCIPgetLowerbound
SCIP_Real SCIPgetLowerbound(SCIP *scip)
Definition: scip_solvingstats.c:1375
SCIPisPrimalboundSol
SCIP_Bool SCIPisPrimalboundSol(SCIP *scip)
Definition: scip_solvingstats.c:1645
SCIPgetAvgPseudocostCurrentRun
SCIP_Real SCIPgetAvgPseudocostCurrentRun(SCIP *scip, SCIP_Real solvaldelta)
Definition: scip_solvingstats.c:1831
SCIPgetNTotalNodes
SCIP_Longint SCIPgetNTotalNodes(SCIP *scip)
Definition: scip_solvingstats.c:239
SCIPgetNBarrierLPIterations
SCIP_Longint SCIPgetNBarrierLPIterations(SCIP *scip)
Definition: scip_solvingstats.c:618
SCIPgetNPrimalResolveLPIterations
SCIP_Longint SCIPgetNPrimalResolveLPIterations(SCIP *scip)
Definition: scip_solvingstats.c:694
SCIPprintRootStatistics
void SCIPprintRootStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:3856
SCIPgetNNodeLPIterations
SCIP_Longint SCIPgetNNodeLPIterations(SCIP *scip)
Definition: scip_solvingstats.c:786
SCIPgetAvgInferencesCurrentRun
SCIP_Real SCIPgetAvgInferencesCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)
Definition: scip_solvingstats.c:2104
SCIP_Bool
#define SCIP_Bool
Definition: def.h:93
SCIPgetMaxTotalDepth
int SCIPgetMaxTotalDepth(SCIP *scip)
Definition: scip_solvingstats.c:1226
SCIPprintRelaxatorStatistics
void SCIPprintRelaxatorStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:3456
SCIPprintTreeStatistics
void SCIPprintTreeStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:3498
SCIPprintSolutionStatistics
void SCIPprintSolutionStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:3548
SCIPgetPseudocostVariance
SCIP_Real SCIPgetPseudocostVariance(SCIP *scip, SCIP_BRANCHDIR branchdir, SCIP_Bool onlycurrentrun)
Definition: scip_solvingstats.c:1912
SCIPgetGap
SCIP_Real SCIPgetGap(SCIP *scip)
Definition: scip_solvingstats.c:1668
SCIPgetAvgConflictlengthScoreCurrentRun
SCIP_Real SCIPgetAvgConflictlengthScoreCurrentRun(SCIP *scip)
Definition: scip_solvingstats.c:2061
SCIPprintExpressionHandlerStatistics
void SCIPprintExpressionHandlerStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:3983
SCIPwriteImplicationConflictGraph
SCIP_RETCODE SCIPwriteImplicationConflictGraph(SCIP *scip, const char *filename)
Definition: scip_solvingstats.c:4443
SCIPgetNPrimalLPs
SCIP_Longint SCIPgetNPrimalLPs(SCIP *scip)
Definition: scip_solvingstats.c:528
SCIPgetNConflictConssFound
SCIP_Longint SCIPgetNConflictConssFound(SCIP *scip)
Definition: scip_solvingstats.c:1094
SCIPgetAvgCutoffsCurrentRun
SCIP_Real SCIPgetAvgCutoffsCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)
Definition: scip_solvingstats.c:2190
SCIPprintNLPStatistics
void SCIPprintNLPStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:3430
SCIPgetNDualResolveLPs
SCIP_Longint SCIPgetNDualResolveLPs(SCIP *scip)
Definition: scip_solvingstats.c:712
SCIPgetNDualLPIterations
SCIP_Longint SCIPgetNDualLPIterations(SCIP *scip)
Definition: scip_solvingstats.c:582
SCIPgetNRuns
int SCIPgetNRuns(SCIP *scip)
Definition: scip_solvingstats.c:129
SCIPgetNConflictConssApplied
SCIP_Longint SCIPgetNConflictConssApplied(SCIP *scip)
Definition: scip_solvingstats.c:1153
SCIPgetNObjlimLeaves
SCIP_Longint SCIPgetNObjlimLeaves(SCIP *scip)
Definition: scip_solvingstats.c:320
SCIPprintNLPIStatistics
void SCIPprintNLPIStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:4042
SCIPprintPricerStatistics
void SCIPprintPricerStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:3085
SCIPgetAvgDualbound
SCIP_Real SCIPgetAvgDualbound(SCIP *scip)
Definition: scip_solvingstats.c:1305
SCIPgetNResolveLPs
SCIP_Longint SCIPgetNResolveLPs(SCIP *scip)
Definition: scip_solvingstats.c:636
SCIPgetAvgCutoffScore
SCIP_Real SCIPgetAvgCutoffScore(SCIP *scip)
Definition: scip_solvingstats.c:2208
SCIPgetNNodeInitLPIterations
SCIP_Longint SCIPgetNNodeInitLPIterations(SCIP *scip)
Definition: scip_solvingstats.c:822
SCIPgetNNodeInitLPs
SCIP_Longint SCIPgetNNodeInitLPs(SCIP *scip)
Definition: scip_solvingstats.c:804
SCIPgetAvgConflictlengthScore
SCIP_Real SCIPgetAvgConflictlengthScore(SCIP *scip)
Definition: scip_solvingstats.c:2036
SCIPgetNStrongbranchLPIterations
SCIP_Longint SCIPgetNStrongbranchLPIterations(SCIP *scip)
Definition: scip_solvingstats.c:894
SCIPgetNReoptRuns
int SCIPgetNReoptRuns(SCIP *scip)
Definition: scip_solvingstats.c:156
SCIPgetNDivingLPs
SCIP_Longint SCIPgetNDivingLPs(SCIP *scip)
Definition: scip_solvingstats.c:840
SCIPprintCutselectorStatistics
void SCIPprintCutselectorStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:3044
SCIPgetNPricevars
int SCIPgetNPricevars(SCIP *scip)
Definition: scip_solvingstats.c:964
SCIPgetNPrimalLPIterations
SCIP_Longint SCIPgetNPrimalLPIterations(SCIP *scip)
Definition: scip_solvingstats.c:546
SCIPgetAvgPseudocostCount
SCIP_Real SCIPgetAvgPseudocostCount(SCIP *scip, SCIP_BRANCHDIR dir)
Definition: scip_solvingstats.c:1849
SCIPgetNPriceRounds
int SCIPgetNPriceRounds(SCIP *scip)
Definition: scip_solvingstats.c:946
SCIPgetNImplications
int SCIPgetNImplications(SCIP *scip)
Definition: scip_solvingstats.c:4415
SCIPgetAvgInferenceScoreCurrentRun
SCIP_Real SCIPgetAvgInferenceScoreCurrentRun(SCIP *scip)
Definition: scip_solvingstats.c:2147
SCIPgetNBestSolsFound
SCIP_Longint SCIPgetNBestSolsFound(SCIP *scip)
Definition: scip_solvingstats.c:1794
SCIP_Real
#define SCIP_Real
Definition: def.h:186
SCIPgetNPricevarsFound
int SCIPgetNPricevarsFound(SCIP *scip)
Definition: scip_solvingstats.c:982
type_history.h
type definitions for branching and inference history
SCIPprintConstraintTimingStatistics
void SCIPprintConstraintTimingStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:2683
SCIPgetNConflictConssFoundNode
int SCIPgetNConflictConssFoundNode(SCIP *scip)
Definition: scip_solvingstats.c:1129
SCIP_Longint
#define SCIP_Longint
Definition: def.h:171
type_message.h
type definitions for message output methods
SCIPgetAvgPseudocostScore
SCIP_Real SCIPgetAvgPseudocostScore(SCIP *scip)
Definition: scip_solvingstats.c:1889
SCIPgetNLimSolsFound
SCIP_Longint SCIPgetNLimSolsFound(SCIP *scip)
Definition: scip_solvingstats.c:1767
nnodes
#define nnodes
Definition: gastrans.c:74
SCIPgetNPricevarsApplied
int SCIPgetNPricevarsApplied(SCIP *scip)
Definition: scip_solvingstats.c:1000
SCIPgetAvgPseudocost
SCIP_Real SCIPgetAvgPseudocost(SCIP *scip, SCIP_Real solvaldelta)
Definition: scip_solvingstats.c:1811
SCIPgetUpperbound
SCIP_Real SCIPgetUpperbound(SCIP *scip)
Definition: scip_solvingstats.c:1555
def.h
common defines and data types used in all packages of SCIP
SCIPgetNNodeZeroIterationLPs
SCIP_Longint SCIPgetNNodeZeroIterationLPs(SCIP *scip)
Definition: scip_solvingstats.c:768
SCIPaddNNodes
void SCIPaddNNodes(SCIP *scip, SCIP_Longint nnodes)
Definition: scip_solvingstats.c:183
SCIPgetNEnabledConss
int SCIPgetNEnabledConss(SCIP *scip)
Definition: scip_solvingstats.c:1287
SCIPgetNNodes
SCIP_Longint SCIPgetNNodes(SCIP *scip)
Definition: scip_solvingstats.c:212
SCIPgetNLPs
SCIP_Longint SCIPgetNLPs(SCIP *scip)
Definition: scip_solvingstats.c:428
SCIPgetNInfeasibleLeaves
SCIP_Longint SCIPgetNInfeasibleLeaves(SCIP *scip)
Definition: scip_solvingstats.c:293
SCIPgetAvgConflictScoreCurrentRun
SCIP_Real SCIPgetAvgConflictScoreCurrentRun(SCIP *scip)
Definition: scip_solvingstats.c:2011
SCIPprintOrigProblemStatistics
void SCIPprintOrigProblemStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:2453
SCIPgetNFeasibleLeaves
SCIP_Longint SCIPgetNFeasibleLeaves(SCIP *scip)
Definition: scip_solvingstats.c:266
SCIPgetNRootStrongbranchs
SCIP_Longint SCIPgetNRootStrongbranchs(SCIP *scip)
Definition: scip_solvingstats.c:912
SCIPgetAvgInferenceScore
SCIP_Real SCIPgetAvgInferenceScore(SCIP *scip)
Definition: scip_solvingstats.c:2122
SCIPgetNSepaRounds
int SCIPgetNSepaRounds(SCIP *scip)
Definition: scip_solvingstats.c:1016
SCIPgetPseudocostCount
SCIP_Real SCIPgetPseudocostCount(SCIP *scip, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun)
Definition: scip_solvingstats.c:1937
SCIPgetAvgInferences
SCIP_Real SCIPgetAvgInferences(SCIP *scip, SCIP_BRANCHDIR dir)
Definition: scip_solvingstats.c:2084