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