SCIP Doxygen Documentation
 
Loading...
Searching...
No Matches
scip_solvingstats.h
Go to the documentation of this file.
1/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2/* */
3/* This file is part of the program and library */
4/* SCIP --- Solving Constraint Integer Programs */
5/* */
6/* Copyright (c) 2002-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
51extern "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 */
78int 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 */
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 */
124void 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 */
148SCIP_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 */
171SCIP_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 */
194SCIP_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 */
217SCIP_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 */
240SCIP_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 */
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 */
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 */
309SCIP_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 */
332SCIP_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 */
347SCIP_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 */
369SCIP_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 */
384SCIP_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 */
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 */
413SCIP_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 */
427SCIP_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 */
441SCIP_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 */
455SCIP_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 */
469SCIP_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 */
483SCIP_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 */
497SCIP_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 */
513SCIP_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 */
527SCIP_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 */
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 */
557SCIP_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 */
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 */
587SCIP_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 */
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 */
615SCIP_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 */
629SCIP_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 */
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 */
657SCIP_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 */
671SCIP_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 */
685SCIP_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 */
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 */
713SCIP_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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
855SCIP_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 */
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 */
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 */
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 */
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 */
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 */
975SCIP_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 */
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 */
1005 SCIP* scip /**< SCIP data structure */
1006 );
1007
1008/** gets average dual bound of all unprocessed nodes for original problem */
1010SCIP_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 */
1024SCIP_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 */
1043SCIP_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 */
1062SCIP_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 */
1079SCIP_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 */
1096SCIP_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 */
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 */
1131 SCIP* scip /**< SCIP data structure */
1132 );
1133
1134
1135/** the primal bound of the very first solution */
1137SCIP_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 */
1157SCIP_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 */
1177SCIP_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 */
1200SCIP_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 */
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 */
1245SCIP_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 */
1261SCIP_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 */
1277SCIP_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 */
1297SCIP_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 */
1320SCIP_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 */
1340SCIP_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 */
1353SCIP_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 */
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 */
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 */
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 */
1413SCIP_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 */
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 */
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 */
1459 SCIP* scip /**< SCIP data structure */
1460 );
1461
1462/** gets the average conflict score value over all variables */
1464SCIP_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 */
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 */
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 */
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 */
1518SCIP_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 */
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 */
1548SCIP_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 */
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 */
1576SCIP_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 */
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 */
1606SCIP_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 */
1620 SCIP* scip /**< SCIP data structure */
1621 );
1622
1623/** gets deterministic time number of LPs solved so far
1624 *
1625 * @return the total number of LPs solved so far
1626 *
1627 * @pre This method can be called if SCIP is in one of the following stages:
1628 * - \ref SCIP_STAGE_PRESOLVED
1629 * - \ref SCIP_STAGE_SOLVING
1630 * - \ref SCIP_STAGE_SOLVED
1631 */
1633SCIP_Real SCIPgetDeterministicTime(
1634 SCIP* scip /**< SCIP data structure */
1635 );
1636
1637/** outputs original problem to file stream
1638 *
1639 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1640 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1641 *
1642 * @pre This method can be called if SCIP is in one of the following stages:
1643 * - \ref SCIP_STAGE_PROBLEM
1644 * - \ref SCIP_STAGE_TRANSFORMING
1645 * - \ref SCIP_STAGE_TRANSFORMED
1646 * - \ref SCIP_STAGE_INITPRESOLVE
1647 * - \ref SCIP_STAGE_PRESOLVING
1648 * - \ref SCIP_STAGE_EXITPRESOLVE
1649 * - \ref SCIP_STAGE_PRESOLVED
1650 * - \ref SCIP_STAGE_INITSOLVE
1651 * - \ref SCIP_STAGE_SOLVING
1652 * - \ref SCIP_STAGE_SOLVED
1653 * - \ref SCIP_STAGE_EXITSOLVE
1654 * - \ref SCIP_STAGE_FREETRANS
1655 */
1658 SCIP* scip, /**< SCIP data structure */
1659 FILE* file, /**< output file (or NULL for standard output) */
1660 const char* extension, /**< file format (or NULL for default CIP format)*/
1661 SCIP_Bool genericnames /**< using generic variable and constraint names? */
1662 );
1663
1664/** outputs transformed problem of the current node to file stream
1665 *
1666 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1667 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1668 *
1669 * @pre This method can be called if SCIP is in one of the following stages:
1670 * - \ref SCIP_STAGE_TRANSFORMED
1671 * - \ref SCIP_STAGE_INITPRESOLVE
1672 * - \ref SCIP_STAGE_PRESOLVING
1673 * - \ref SCIP_STAGE_EXITPRESOLVE
1674 * - \ref SCIP_STAGE_PRESOLVED
1675 * - \ref SCIP_STAGE_INITSOLVE
1676 * - \ref SCIP_STAGE_SOLVING
1677 * - \ref SCIP_STAGE_SOLVED
1678 * - \ref SCIP_STAGE_EXITSOLVE
1679 * - \ref SCIP_STAGE_FREETRANS
1680 */
1683 SCIP* scip, /**< SCIP data structure */
1684 FILE* file, /**< output file (or NULL for standard output) */
1685 const char* extension, /**< file format (or NULL for default CIP format)*/
1686 SCIP_Bool genericnames /**< using generic variable and constraint names? */
1687 );
1688
1689/** outputs status statistics
1690 *
1691 * @note If limits have been changed between the solution and the call to this function, the status is recomputed and
1692 * thus may to correspond to the original status.
1693 *
1694 * @pre This method can be called if SCIP is in one of the following stages:
1695 * - \ref SCIP_STAGE_INIT
1696 * - \ref SCIP_STAGE_PROBLEM
1697 * - \ref SCIP_STAGE_TRANSFORMED
1698 * - \ref SCIP_STAGE_INITPRESOLVE
1699 * - \ref SCIP_STAGE_PRESOLVING
1700 * - \ref SCIP_STAGE_EXITPRESOLVE
1701 * - \ref SCIP_STAGE_PRESOLVED
1702 * - \ref SCIP_STAGE_SOLVING
1703 * - \ref SCIP_STAGE_SOLVED
1704 */
1707 SCIP* scip, /**< SCIP data structure */
1708 FILE* file /**< output file */
1709 );
1710
1711/** outputs timing statistics
1712 *
1713 * @pre This method can be called if SCIP is in one of the following stages:
1714 * - \ref SCIP_STAGE_PROBLEM
1715 * - \ref SCIP_STAGE_TRANSFORMED
1716 * - \ref SCIP_STAGE_INITPRESOLVE
1717 * - \ref SCIP_STAGE_PRESOLVING
1718 * - \ref SCIP_STAGE_EXITPRESOLVE
1719 * - \ref SCIP_STAGE_PRESOLVED
1720 * - \ref SCIP_STAGE_SOLVING
1721 * - \ref SCIP_STAGE_SOLVED
1722 */
1725 SCIP* scip, /**< SCIP data structure */
1726 FILE* file /**< output file */
1727 );
1728
1729/** outputs statistics for original problem
1730 *
1731 * @pre This method can be called if SCIP is in one of the following stages:
1732 * - \ref SCIP_STAGE_PROBLEM
1733 * - \ref SCIP_STAGE_TRANSFORMED
1734 * - \ref SCIP_STAGE_INITPRESOLVE
1735 * - \ref SCIP_STAGE_PRESOLVING
1736 * - \ref SCIP_STAGE_EXITPRESOLVE
1737 * - \ref SCIP_STAGE_PRESOLVED
1738 * - \ref SCIP_STAGE_SOLVING
1739 * - \ref SCIP_STAGE_SOLVED
1740 */
1743 SCIP* scip, /**< SCIP data structure */
1744 FILE* file /**< output file (or NULL for standard output) */
1745 );
1746
1747/** outputs statistics for transformed problem
1748 *
1749 * @pre This method can be called if SCIP is in one of the following stages:
1750 * - \ref SCIP_STAGE_PROBLEM
1751 * - \ref SCIP_STAGE_TRANSFORMED
1752 * - \ref SCIP_STAGE_INITPRESOLVE
1753 * - \ref SCIP_STAGE_PRESOLVING
1754 * - \ref SCIP_STAGE_EXITPRESOLVE
1755 * - \ref SCIP_STAGE_PRESOLVED
1756 * - \ref SCIP_STAGE_SOLVING
1757 * - \ref SCIP_STAGE_SOLVED
1758 */
1761 SCIP* scip, /**< SCIP data structure */
1762 FILE* file /**< output file */
1763 );
1764
1765/** outputs presolver statistics
1766 *
1767 * @pre This method can be called if SCIP is in one of the following stages:
1768 * - \ref SCIP_STAGE_TRANSFORMED
1769 * - \ref SCIP_STAGE_INITPRESOLVE
1770 * - \ref SCIP_STAGE_PRESOLVING
1771 * - \ref SCIP_STAGE_EXITPRESOLVE
1772 * - \ref SCIP_STAGE_PRESOLVED
1773 * - \ref SCIP_STAGE_SOLVING
1774 * - \ref SCIP_STAGE_SOLVED
1775 */
1778 SCIP* scip, /**< SCIP data structure */
1779 FILE* file /**< output file */
1780 );
1781
1782/** outputs constraint statistics
1783 *
1784 * @pre This method can be called if SCIP is in one of the following stages:
1785 * - \ref SCIP_STAGE_TRANSFORMED
1786 * - \ref SCIP_STAGE_INITPRESOLVE
1787 * - \ref SCIP_STAGE_PRESOLVING
1788 * - \ref SCIP_STAGE_EXITPRESOLVE
1789 * - \ref SCIP_STAGE_PRESOLVED
1790 * - \ref SCIP_STAGE_SOLVING
1791 * - \ref SCIP_STAGE_SOLVED
1792 */
1795 SCIP* scip, /**< SCIP data structure */
1796 FILE* file /**< output file */
1797 );
1798
1799/** outputs constraint timing statistics
1800 *
1801 * @pre This method can be called if SCIP is in one of the following stages:
1802 * - \ref SCIP_STAGE_TRANSFORMED
1803 * - \ref SCIP_STAGE_INITPRESOLVE
1804 * - \ref SCIP_STAGE_PRESOLVING
1805 * - \ref SCIP_STAGE_EXITPRESOLVE
1806 * - \ref SCIP_STAGE_PRESOLVED
1807 * - \ref SCIP_STAGE_SOLVING
1808 * - \ref SCIP_STAGE_SOLVED
1809 */
1812 SCIP* scip, /**< SCIP data structure */
1813 FILE* file /**< output file */
1814 );
1815
1816/** outputs propagator statistics
1817 *
1818 * @pre This method can be called if SCIP is in one of the following stages:
1819 * - \ref SCIP_STAGE_TRANSFORMED
1820 * - \ref SCIP_STAGE_INITPRESOLVE
1821 * - \ref SCIP_STAGE_PRESOLVING
1822 * - \ref SCIP_STAGE_EXITPRESOLVE
1823 * - \ref SCIP_STAGE_PRESOLVED
1824 * - \ref SCIP_STAGE_SOLVING
1825 * - \ref SCIP_STAGE_SOLVED
1826 */
1829 SCIP* scip, /**< SCIP data structure */
1830 FILE* file /**< output file */
1831 );
1832
1833/** outputs conflict statistics
1834 *
1835 * @pre This method can be called if SCIP is in one of the following stages:
1836 * - \ref SCIP_STAGE_TRANSFORMED
1837 * - \ref SCIP_STAGE_INITPRESOLVE
1838 * - \ref SCIP_STAGE_PRESOLVING
1839 * - \ref SCIP_STAGE_EXITPRESOLVE
1840 * - \ref SCIP_STAGE_PRESOLVED
1841 * - \ref SCIP_STAGE_SOLVING
1842 * - \ref SCIP_STAGE_SOLVED
1843 */
1846 SCIP* scip, /**< SCIP data structure */
1847 FILE* file /**< output file */
1848 );
1849
1850/** outputs separator statistics
1851 *
1852 * Columns:
1853 * - RootCalls: The number of calls that happened at the root.
1854 * - FoundCuts: The total number of cuts generated by the separators.
1855 * Note: Cutpool-FoundCuts \f$= \sum_{i=1}^nsepas ( Foundcuts_i - DirectAdd_i )\f$.
1856 * - ViaPoolAdd: The total number of cuts added to the sepastore from the cutpool.
1857 * - DirectAdd: The total number of cuts added directly to the sepastore from the separator.
1858 * - Applied: The sum of all cuts from the separator that were applied to the LP.
1859 * - ViaPoolApp: The number of cuts that entered the sepastore from the cutpool that were applied to the LP.
1860 * - DirectApp: The number of cuts that entered the sepastore directly and were applied to the LP.
1861 *
1862 * The number of cuts ViaPoolAdd + Directly should be equal to the number of cuts Filtered + Forced + Selected in the
1863 * cutselector statistics.
1864 *
1865 * @note The following edge case may lead to over or undercounting of statistics: When SCIPapplyCutsProbing() is
1866 * called, cuts are counted for the cut selection statistics, but not for the separator statistics. This
1867 * happens, e.g., in the default plugin prop_obbt.c.
1868 *
1869 * @pre This method can be called if SCIP is in one of the following stages:
1870 * - \ref SCIP_STAGE_SOLVING
1871 * - \ref SCIP_STAGE_SOLVED
1872 */
1875 SCIP* scip, /**< SCIP data structure */
1876 FILE* file /**< output file */
1877 );
1878
1879/** outputs cutselector statistics
1880 *
1881 * @pre This method can be called if SCIP is in one of the following stages:
1882 * - \ref SCIP_STAGE_SOLVING
1883 * - \ref SCIP_STAGE_SOLVED
1884 */
1887 SCIP* scip, /**< SCIP data structure */
1888 FILE* file /**< output file */
1889 );
1890
1891/** outputs pricer statistics
1892 *
1893 * @pre This method can be called if SCIP is in one of the following stages:
1894 * - \ref SCIP_STAGE_SOLVING
1895 * - \ref SCIP_STAGE_SOLVED
1896 */
1899 SCIP* scip, /**< SCIP data structure */
1900 FILE* file /**< output file */
1901 );
1902
1903/** outputs branching rule statistics
1904 *
1905 * @pre This method can be called if SCIP is in one of the following stages:
1906 * - \ref SCIP_STAGE_SOLVING
1907 * - \ref SCIP_STAGE_SOLVED
1908 */
1911 SCIP* scip, /**< SCIP data structure */
1912 FILE* file /**< output file */
1913 );
1914
1915/** outputs heuristics statistics
1916 *
1917 * @pre This method can be called if SCIP is in one of the following stages:
1918 * - \ref SCIP_STAGE_PRESOLVING
1919 * - \ref SCIP_STAGE_EXITPRESOLVE
1920 * - \ref SCIP_STAGE_PRESOLVED
1921 * - \ref SCIP_STAGE_SOLVING
1922 * - \ref SCIP_STAGE_SOLVED
1923 */
1926 SCIP* scip, /**< SCIP data structure */
1927 FILE* file /**< output file */
1928 );
1929
1930/** outputs compression statistics
1931 *
1932 * @pre This method can be called if SCIP is in one of the following stages:
1933 * - \ref SCIP_STAGE_PRESOLVING
1934 * - \ref SCIP_STAGE_EXITPRESOLVE
1935 * - \ref SCIP_STAGE_PRESOLVED
1936 * - \ref SCIP_STAGE_SOLVING
1937 * - \ref SCIP_STAGE_SOLVED
1938 */
1941 SCIP* scip, /**< SCIP data structure */
1942 FILE* file /**< output file */
1943 );
1944
1945/** outputs LP statistics
1946 *
1947 * @pre This method can be called if SCIP is in one of the following stages:
1948 * - \ref SCIP_STAGE_SOLVING
1949 * - \ref SCIP_STAGE_SOLVED
1950 */
1953 SCIP* scip, /**< SCIP data structure */
1954 FILE* file /**< output file */
1955 );
1956
1957/** outputs NLP statistics
1958 *
1959 * @pre This method can be called if SCIP is in one of the following stages:
1960 * - \ref SCIP_STAGE_SOLVING
1961 * - \ref SCIP_STAGE_SOLVED
1962 */
1965 SCIP* scip, /**< SCIP data structure */
1966 FILE* file /**< output file */
1967 );
1968
1969/** outputs relaxator statistics
1970 *
1971 * @pre This method can be called if SCIP is in one of the following stages:
1972 * - \ref SCIP_STAGE_SOLVING
1973 * - \ref SCIP_STAGE_SOLVED
1974 */
1977 SCIP* scip, /**< SCIP data structure */
1978 FILE* file /**< output file */
1979 );
1980
1981/** outputs tree statistics
1982 *
1983 * @pre This method can be called if SCIP is in one of the following stages:
1984 * - \ref SCIP_STAGE_SOLVING
1985 * - \ref SCIP_STAGE_SOLVED
1986 */
1989 SCIP* scip, /**< SCIP data structure */
1990 FILE* file /**< output file */
1991 );
1992
1993/** outputs root statistics
1994 *
1995 * @pre This method can be called if SCIP is in one of the following stages:
1996 * - \ref SCIP_STAGE_SOLVING
1997 * - \ref SCIP_STAGE_SOLVED
1998 */
2001 SCIP* scip, /**< SCIP data structure */
2002 FILE* file /**< output file */
2003 );
2004
2005/** outputs solution statistics
2006 *
2007 * @pre This method can be called if SCIP is in one of the following stages:
2008 * - \ref SCIP_STAGE_PRESOLVING
2009 * - \ref SCIP_STAGE_EXITPRESOLVE
2010 * - \ref SCIP_STAGE_PRESOLVED
2011 * - \ref SCIP_STAGE_SOLVING
2012 * - \ref SCIP_STAGE_SOLVED
2013 */
2016 SCIP* scip, /**< SCIP data structure */
2017 FILE* file /**< output file */
2018 );
2019
2020/** outputs concurrent solver statistics
2021 *
2022 * @pre This method can be called if SCIP is in one of the following stages:
2023 * - \ref SCIP_STAGE_TRANSFORMED
2024 * - \ref SCIP_STAGE_INITPRESOLVE
2025 * - \ref SCIP_STAGE_PRESOLVING
2026 * - \ref SCIP_STAGE_EXITPRESOLVE
2027 * - \ref SCIP_STAGE_PRESOLVED
2028 * - \ref SCIP_STAGE_SOLVING
2029 * - \ref SCIP_STAGE_SOLVED
2030 */
2033 SCIP* scip, /**< SCIP data structure */
2034 FILE* file /**< output file */
2035 );
2036
2037/** outputs Benders' decomposition statistics
2038 *
2039 * @pre This method can be called if SCIP is in one of the following stages:
2040 * - \ref SCIP_STAGE_SOLVING
2041 * - \ref SCIP_STAGE_SOLVED
2042 */
2045 SCIP* scip, /**< SCIP data structure */
2046 FILE* file /**< output file */
2047 );
2048
2049/** outputs expression handler statistics
2050 *
2051 * @pre This method can be called if SCIP is in one of the following stages:
2052 * - \ref SCIP_STAGE_PROBLEM
2053 * - \ref SCIP_STAGE_TRANSFORMED
2054 * - \ref SCIP_STAGE_INITPRESOLVE
2055 * - \ref SCIP_STAGE_PRESOLVING
2056 * - \ref SCIP_STAGE_EXITPRESOLVE
2057 * - \ref SCIP_STAGE_PRESOLVED
2058 * - \ref SCIP_STAGE_SOLVING
2059 * - \ref SCIP_STAGE_SOLVED
2060 */
2063 SCIP* scip, /**< SCIP data structure */
2064 FILE* file /**< output file */
2065 );
2066
2067/** outputs NLPI statistics
2068 *
2069 * @pre This method can be called if SCIP is in one of the following stages:
2070 * - \ref SCIP_STAGE_PROBLEM
2071 * - \ref SCIP_STAGE_TRANSFORMED
2072 * - \ref SCIP_STAGE_INITPRESOLVE
2073 * - \ref SCIP_STAGE_PRESOLVING
2074 * - \ref SCIP_STAGE_EXITPRESOLVE
2075 * - \ref SCIP_STAGE_PRESOLVED
2076 * - \ref SCIP_STAGE_SOLVING
2077 * - \ref SCIP_STAGE_SOLVED
2078 */
2081 SCIP* scip, /**< SCIP data structure */
2082 FILE* file /**< output file */
2083 );
2084
2085/** outputs solving statistics
2086 *
2087 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2088 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2089 *
2090 * @note If limits have been changed between the solution and the call to this function, the status is recomputed and
2091 * thus may to correspond to the original status.
2092 *
2093 * @pre This method can be called if SCIP is in one of the following stages:
2094 * - \ref SCIP_STAGE_INIT
2095 * - \ref SCIP_STAGE_PROBLEM
2096 * - \ref SCIP_STAGE_TRANSFORMED
2097 * - \ref SCIP_STAGE_INITPRESOLVE
2098 * - \ref SCIP_STAGE_PRESOLVING
2099 * - \ref SCIP_STAGE_EXITPRESOLVE
2100 * - \ref SCIP_STAGE_PRESOLVED
2101 * - \ref SCIP_STAGE_SOLVING
2102 * - \ref SCIP_STAGE_SOLVED
2103 */
2106 SCIP* scip, /**< SCIP data structure */
2107 FILE* file /**< output file (or NULL for standard output) */
2108 );
2109
2110/** outputs reoptimization statistics
2111 *
2112 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2113 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2114 *
2115 * @pre This method can be called if SCIP is in one of the following stages:
2116 * - \ref SCIP_STAGE_INIT
2117 * - \ref SCIP_STAGE_PROBLEM
2118 * - \ref SCIP_STAGE_TRANSFORMED
2119 * - \ref SCIP_STAGE_INITPRESOLVE
2120 * - \ref SCIP_STAGE_PRESOLVING
2121 * - \ref SCIP_STAGE_EXITPRESOLVE
2122 * - \ref SCIP_STAGE_PRESOLVED
2123 * - \ref SCIP_STAGE_SOLVING
2124 * - \ref SCIP_STAGE_SOLVED
2125 */
2128 SCIP* scip, /**< SCIP data structure */
2129 FILE* file /**< output file (or NULL for standard output) */
2130 );
2131
2132/** outputs history statistics about branchings on variables
2133 *
2134 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2135 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2136 *
2137 * @pre This method can be called if SCIP is in one of the following stages:
2138 * - \ref SCIP_STAGE_INIT
2139 * - \ref SCIP_STAGE_PROBLEM
2140 * - \ref SCIP_STAGE_TRANSFORMED
2141 * - \ref SCIP_STAGE_INITPRESOLVE
2142 * - \ref SCIP_STAGE_PRESOLVING
2143 * - \ref SCIP_STAGE_EXITPRESOLVE
2144 * - \ref SCIP_STAGE_PRESOLVED
2145 * - \ref SCIP_STAGE_SOLVING
2146 * - \ref SCIP_STAGE_SOLVED
2147 */
2150 SCIP* scip, /**< SCIP data structure */
2151 FILE* file /**< output file (or NULL for standard output) */
2152 );
2153
2154/** outputs node information display line
2155 *
2156 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2157 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2158 *
2159 * @pre This method can be called if SCIP is in one of the following stages:
2160 * - \ref SCIP_STAGE_SOLVING
2161 */
2164 SCIP* scip, /**< SCIP data structure */
2165 FILE* file, /**< output file (or NULL for standard output) */
2166 SCIP_VERBLEVEL verblevel, /**< minimal verbosity level to actually display the information line */
2167 SCIP_Bool endline /**< should the line be terminated with a newline symbol? */
2168 );
2169
2170/** gets total number of implications between variables that are stored in the implication graph
2171 *
2172 * @return the total number of implications between variables that are stored in the implication graph
2173 *
2174 * @pre This method can be called if SCIP is in one of the following stages:
2175 * - \ref SCIP_STAGE_INITPRESOLVE
2176 * - \ref SCIP_STAGE_PRESOLVING
2177 * - \ref SCIP_STAGE_EXITPRESOLVE
2178 * - \ref SCIP_STAGE_PRESOLVED
2179 * - \ref SCIP_STAGE_INITSOLVE
2180 * - \ref SCIP_STAGE_SOLVING
2181 * - \ref SCIP_STAGE_SOLVED
2182 */
2185 SCIP* scip /**< SCIP data structure */
2186 );
2187
2188/** stores conflict graph of binary variables' implications into a file, which can be used as input for the DOT tool
2189 *
2190 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2191 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2192 *
2193 * @pre This method can be called if SCIP is in one of the following stages:
2194 * - \ref SCIP_STAGE_TRANSFORMED
2195 * - \ref SCIP_STAGE_INITPRESOLVE
2196 * - \ref SCIP_STAGE_PRESOLVING
2197 * - \ref SCIP_STAGE_EXITPRESOLVE
2198 * - \ref SCIP_STAGE_PRESOLVED
2199 * - \ref SCIP_STAGE_INITSOLVE
2200 * - \ref SCIP_STAGE_SOLVING
2201 * - \ref SCIP_STAGE_SOLVED
2202 * - \ref SCIP_STAGE_EXITSOLVE
2203 *
2204 * @deprecated because binary implications are now stored as cliques
2205 */
2208 SCIP* scip, /**< SCIP data structure */
2209 const char* filename /**< file name, or NULL for stdout */
2210 );
2211
2212
2213/** update statistical information when a new solution was found */
2216 SCIP* scip /**< SCIP data structure */
2217 );
2218
2219/**@} */
2220
2221#ifdef __cplusplus
2222}
2223#endif
2224
2225#endif
common defines and data types used in all packages of SCIP
#define nnodes
Definition gastrans.c:74
void SCIPprintPropagatorStatistics(SCIP *scip, FILE *file)
void SCIPprintTreeStatistics(SCIP *scip, FILE *file)
void SCIPprintStatusStatistics(SCIP *scip, FILE *file)
SCIP_Real SCIPgetAvgConflictScoreCurrentRun(SCIP *scip)
void SCIPprintCompressionStatistics(SCIP *scip, FILE *file)
SCIP_Real SCIPgetAvgCutoffsCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)
void SCIPprintRootStatistics(SCIP *scip, FILE *file)
SCIP_Bool SCIPisPrimalboundSol(SCIP *scip)
SCIP_Longint SCIPgetNConflictDualproofsApplied(SCIP *scip)
int SCIPgetNImplications(SCIP *scip)
void SCIPprintConstraintTimingStatistics(SCIP *scip, FILE *file)
void SCIPaddNNodes(SCIP *scip, SCIP_Longint nnodes)
SCIP_Real SCIPgetDeterministicTime(SCIP *scip)
SCIP_Longint SCIPgetNSolsFound(SCIP *scip)
SCIP_Real SCIPgetPrimalbound(SCIP *scip)
int SCIPgetMaxDepth(SCIP *scip)
SCIP_RETCODE SCIPupdateCutoffbound(SCIP *scip, SCIP_Real cutoffbound)
SCIP_Longint SCIPgetNBarrierLPIterations(SCIP *scip)
SCIP_Real SCIPgetAvgInferenceScore(SCIP *scip)
SCIP_Longint SCIPgetNDivingLPIterations(SCIP *scip)
SCIP_Real SCIPgetAvgPseudocostScoreCurrentRun(SCIP *scip)
SCIP_Real SCIPgetUpperbound(SCIP *scip)
SCIP_Real SCIPgetLowerboundRoot(SCIP *scip)
SCIP_Real SCIPgetAvgConflictlengthScore(SCIP *scip)
void SCIPprintSolutionStatistics(SCIP *scip, FILE *file)
SCIP_Real SCIPgetAvgPseudocostCount(SCIP *scip, SCIP_BRANCHDIR dir)
SCIP_Longint SCIPgetNInfeasibleLeaves(SCIP *scip)
void SCIPprintRelaxatorStatistics(SCIP *scip, FILE *file)
SCIP_Real SCIPgetGap(SCIP *scip)
SCIP_Longint SCIPgetNResolveLPIterations(SCIP *scip)
void SCIPprintOrigProblemStatistics(SCIP *scip, FILE *file)
SCIP_Longint SCIPgetNNodeZeroIterationLPs(SCIP *scip)
SCIP_Longint SCIPgetNNodes(SCIP *scip)
SCIP_Longint SCIPgetNFeasibleLeaves(SCIP *scip)
SCIP_Longint SCIPgetNNodeInitLPs(SCIP *scip)
int SCIPgetMaxTotalDepth(SCIP *scip)
int SCIPgetNPricevars(SCIP *scip)
int SCIPgetNRootboundChgsRun(SCIP *scip)
SCIP_Real SCIPgetDualbound(SCIP *scip)
void SCIPprintLPStatistics(SCIP *scip, FILE *file)
SCIP_Longint SCIPgetNRootStrongbranchs(SCIP *scip)
int SCIPgetNEnabledConss(SCIP *scip)
int SCIPgetNSepaRounds(SCIP *scip)
int SCIPgetNCutsFoundRound(SCIP *scip)
void SCIPprintNLPStatistics(SCIP *scip, FILE *file)
int SCIPgetNRootboundChgs(SCIP *scip)
SCIP_Real SCIPgetFirstPrimalBound(SCIP *scip)
SCIP_Longint SCIPgetNStrongbranchLPIterations(SCIP *scip)
int SCIPgetNPricevarsApplied(SCIP *scip)
int SCIPgetNCutsApplied(SCIP *scip)
void SCIPprintPricerStatistics(SCIP *scip, FILE *file)
SCIP_RETCODE SCIPprintStatistics(SCIP *scip, FILE *file)
SCIP_Real SCIPgetLowerbound(SCIP *scip)
SCIP_Real SCIPgetAvgLowerbound(SCIP *scip)
SCIP_RETCODE SCIPprintBranchingStatistics(SCIP *scip, FILE *file)
SCIP_Longint SCIPgetNTotalNodes(SCIP *scip)
void SCIPprintSeparatorStatistics(SCIP *scip, FILE *file)
void SCIPprintConcsolverStatistics(SCIP *scip, FILE *file)
SCIP_Longint SCIPgetNResolveLPs(SCIP *scip)
int SCIPgetNRuns(SCIP *scip)
void SCIPprintNLPIStatistics(SCIP *scip, FILE *file)
SCIP_Longint SCIPgetNNodeLPIterations(SCIP *scip)
SCIP_Longint SCIPgetNDualLPIterations(SCIP *scip)
void SCIPprintBranchruleStatistics(SCIP *scip, FILE *file)
int SCIPgetNActiveConss(SCIP *scip)
void SCIPprintConflictStatistics(SCIP *scip, FILE *file)
SCIP_Real SCIPgetDualboundRoot(SCIP *scip)
SCIP_Longint SCIPgetNDualLPs(SCIP *scip)
SCIP_Real SCIPgetAvgCutoffScoreCurrentRun(SCIP *scip)
void SCIPprintExpressionHandlerStatistics(SCIP *scip, FILE *file)
int SCIPgetNPriceRounds(SCIP *scip)
SCIP_Longint SCIPgetNLPs(SCIP *scip)
int SCIPgetNReoptRuns(SCIP *scip)
SCIP_Real SCIPgetAvgDualbound(SCIP *scip)
void SCIPprintBendersStatistics(SCIP *scip, FILE *file)
void SCIPprintTimingStatistics(SCIP *scip, FILE *file)
SCIP_Longint SCIPgetNRootLPIterations(SCIP *scip)
SCIP_Longint SCIPgetNPrimalResolveLPIterations(SCIP *scip)
SCIP_Real SCIPgetAvgInferenceScoreCurrentRun(SCIP *scip)
void SCIPprintCutselectorStatistics(SCIP *scip, FILE *file)
SCIP_Real SCIPgetAvgConflictScore(SCIP *scip)
SCIP_Longint SCIPgetNLimSolsFound(SCIP *scip)
void SCIPstoreSolutionGap(SCIP *scip)
SCIP_Real SCIPgetAvgPseudocost(SCIP *scip, SCIP_Real solvaldelta)
void SCIPprintConstraintStatistics(SCIP *scip, FILE *file)
SCIP_RETCODE SCIPprintTransProblem(SCIP *scip, FILE *file, const char *extension, SCIP_Bool genericnames)
SCIP_Longint SCIPgetNBacktracks(SCIP *scip)
SCIP_RETCODE SCIPprintReoptStatistics(SCIP *scip, FILE *file)
SCIP_Longint SCIPgetNBarrierLPs(SCIP *scip)
SCIP_RETCODE SCIPprintOrigProblem(SCIP *scip, FILE *file, const char *extension, SCIP_Bool genericnames)
SCIP_Longint SCIPgetNDualResolveLPIterations(SCIP *scip)
SCIP_Real SCIPgetTransGap(SCIP *scip)
SCIP_Longint SCIPgetNBestSolsFound(SCIP *scip)
SCIP_RETCODE SCIPwriteImplicationConflictGraph(SCIP *scip, const char *filename)
SCIP_Real SCIPgetAvgPseudocostScore(SCIP *scip)
SCIP_Real SCIPgetPseudocostCount(SCIP *scip, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun)
SCIP_Real SCIPgetCutoffbound(SCIP *scip)
SCIP_Real SCIPgetFirstLPLowerboundRoot(SCIP *scip)
SCIP_Real SCIPgetAvgPseudocostCountCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)
SCIP_Longint SCIPgetNConflictConssApplied(SCIP *scip)
SCIP_Longint SCIPgetNObjlimLeaves(SCIP *scip)
int SCIPgetNCutsFound(SCIP *scip)
void SCIPprintPresolverStatistics(SCIP *scip, FILE *file)
void SCIPprintTransProblemStatistics(SCIP *scip, FILE *file)
SCIP_RETCODE SCIPprintDisplayLine(SCIP *scip, FILE *file, SCIP_VERBLEVEL verblevel, SCIP_Bool endline)
SCIP_Longint SCIPgetNDivingLPs(SCIP *scip)
SCIP_Longint SCIPgetNNodeLPs(SCIP *scip)
SCIP_Real SCIPgetFirstLPDualboundRoot(SCIP *scip)
SCIP_Real SCIPgetAvgConflictlengthScoreCurrentRun(SCIP *scip)
SCIP_Longint SCIPgetNRootFirstLPIterations(SCIP *scip)
int SCIPgetNPricevarsFound(SCIP *scip)
SCIP_Longint SCIPgetNNodeInitLPIterations(SCIP *scip)
SCIP_Longint SCIPgetNNZs(SCIP *scip)
SCIP_Longint SCIPgetNDelayedCutoffs(SCIP *scip)
SCIP_Longint SCIPgetNPrimalResolveLPs(SCIP *scip)
SCIP_Longint SCIPgetNConflictConssFound(SCIP *scip)
SCIP_Real SCIPgetAvgPseudocostCurrentRun(SCIP *scip, SCIP_Real solvaldelta)
SCIP_Real SCIPgetAvgInferences(SCIP *scip, SCIP_BRANCHDIR dir)
SCIP_Longint SCIPgetNPrimalLPIterations(SCIP *scip)
SCIP_Longint SCIPgetNStrongbranchs(SCIP *scip)
int SCIPgetNConflictConssFoundNode(SCIP *scip)
SCIP_Longint SCIPgetNLPIterations(SCIP *scip)
SCIP_Real SCIPgetAvgInferencesCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)
SCIP_Longint SCIPgetNDualResolveLPs(SCIP *scip)
void SCIPprintHeuristicStatistics(SCIP *scip, FILE *file)
SCIP_Real SCIPgetPseudocostVariance(SCIP *scip, SCIP_BRANCHDIR branchdir, SCIP_Bool onlycurrentrun)
SCIP_Longint SCIPgetNPrimalLPs(SCIP *scip)
SCIP_Real SCIPgetAvgCutoffs(SCIP *scip, SCIP_BRANCHDIR dir)
SCIP_Longint SCIPgetNRootStrongbranchLPIterations(SCIP *scip)
SCIP_Real SCIPgetAvgCutoffScore(SCIP *scip)
type definitions for branching and inference history
enum SCIP_BranchDir SCIP_BRANCHDIR
type definitions for message output methods
enum SCIP_VerbLevel SCIP_VERBLEVEL
type definitions for return codes for SCIP methods
enum SCIP_Retcode SCIP_RETCODE
type definitions for SCIP's main datastructure