SCIP Doxygen Documentation
 
Loading...
Searching...
No Matches
scip_solvingstats.c
Go to the documentation of this file.
1/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2/* */
3/* This file is part of the program and library */
4/* SCIP --- Solving Constraint Integer Programs */
5/* */
6/* Copyright (c) 2002-2024 Zuse Institute Berlin (ZIB) */
7/* */
8/* Licensed under the Apache License, Version 2.0 (the "License"); */
9/* you may not use this file except in compliance with the License. */
10/* You may obtain a copy of the License at */
11/* */
12/* http://www.apache.org/licenses/LICENSE-2.0 */
13/* */
14/* Unless required by applicable law or agreed to in writing, software */
15/* distributed under the License is distributed on an "AS IS" BASIS, */
16/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
17/* See the License for the specific language governing permissions and */
18/* limitations under the License. */
19/* */
20/* You should have received a copy of the Apache-2.0 license */
21/* along with SCIP; see the file LICENSE. If not visit scipopt.org. */
22/* */
23/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
24
25/**@file scip_solvingstats.c
26 * @ingroup OTHER_CFILES
27 * @brief public methods for querying solving statistics
28 * @author Tobias Achterberg
29 * @author Timo Berthold
30 * @author Gerald Gamrath
31 * @author Leona Gottwald
32 * @author Stefan Heinz
33 * @author Gregor Hendel
34 * @author Thorsten Koch
35 * @author Alexander Martin
36 * @author Marc Pfetsch
37 * @author Michael Winkler
38 * @author Kati Wolter
39 *
40 * @todo check all SCIP_STAGE_* switches, and include the new stages TRANSFORMED and INITSOLVE
41 */
42
43/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
44
46#include "scip/branch.h"
47#include "scip/clock.h"
48#include "scip/concsolver.h"
49#include "scip/concurrent.h"
50#include "scip/conflict.h"
51#include "scip/conflictstore.h"
52#include "scip/debug.h"
53#include "scip/disp.h"
54#include "scip/history.h"
55#include "scip/implics.h"
56#include "scip/pricestore.h"
57#include "scip/primal.h"
58#include "scip/prob.h"
59#include "scip/pub_benderscut.h"
60#include "scip/pub_benders.h"
61#include "scip/pub_branch.h"
62#include "scip/pub_compr.h"
63#include "scip/pub_cons.h"
64#include "scip/pub_cutpool.h"
65#include "scip/pub_cutsel.h"
66#include "scip/pub_expr.h"
67#include "scip/pub_heur.h"
68#include "scip/pub_history.h"
69#include "scip/pub_message.h"
70#include "scip/pub_misc.h"
71#include "scip/pub_misc_sort.h"
72#include "scip/pub_nlpi.h"
73#include "scip/pub_presol.h"
74#include "scip/pub_pricer.h"
75#include "scip/pub_prop.h"
76#include "scip/pub_reader.h"
77#include "scip/pub_relax.h"
78#include "scip/pub_reopt.h"
79#include "scip/pub_sepa.h"
80#include "scip/pub_sol.h"
81#include "scip/pub_table.h"
82#include "scip/pub_var.h"
83#include "scip/reader.h"
84#include "scip/reopt.h"
85#include "scip/scip_benders.h"
86#include "scip/scip_general.h"
87#include "scip/scip_mem.h"
88#include "scip/scip_message.h"
89#include "scip/scip_nlp.h"
90#include "scip/scip_numerics.h"
91#include "scip/scip_sol.h"
93#include "scip/scip_table.h"
94#include "scip/scip_timing.h"
95#include "scip/scip_var.h"
96#include "scip/sepastore.h"
97#include "scip/set.h"
98#include "scip/sol.h"
99#include "scip/stat.h"
100#include "scip/struct_mem.h"
101#include "scip/struct_primal.h"
102#include "scip/struct_prob.h"
103#include "scip/struct_scip.h"
104#include "scip/struct_set.h"
105#include "scip/struct_stat.h"
106#include "scip/syncstore.h"
107#include "scip/table.h"
108#include "scip/tree.h"
109#include "scip/var.h"
110#include <string.h>
111
112/** gets number of branch and bound runs performed, including the current run
113 *
114 * @return the number of branch and bound runs performed, including the current run
115 *
116 * @pre This method can be called if SCIP is in one of the following stages:
117 * - \ref SCIP_STAGE_PROBLEM
118 * - \ref SCIP_STAGE_TRANSFORMING
119 * - \ref SCIP_STAGE_TRANSFORMED
120 * - \ref SCIP_STAGE_INITPRESOLVE
121 * - \ref SCIP_STAGE_PRESOLVING
122 * - \ref SCIP_STAGE_EXITPRESOLVE
123 * - \ref SCIP_STAGE_PRESOLVED
124 * - \ref SCIP_STAGE_INITSOLVE
125 * - \ref SCIP_STAGE_SOLVING
126 * - \ref SCIP_STAGE_SOLVED
127 * - \ref SCIP_STAGE_EXITSOLVE
128 * - \ref SCIP_STAGE_FREETRANS
129 */
131 SCIP* scip /**< SCIP data structure */
132 )
133{
135
136 return scip->stat->nruns;
137}
138
139/** gets number of reoptimization runs performed, including the current run
140 *
141 * @return the number of reoptimization runs performed, including the current run
142 *
143 * @pre This method can be called if SCIP is in one of the following stages:
144 * - \ref SCIP_STAGE_PROBLEM
145 * - \ref SCIP_STAGE_TRANSFORMING
146 * - \ref SCIP_STAGE_TRANSFORMED
147 * - \ref SCIP_STAGE_INITPRESOLVE
148 * - \ref SCIP_STAGE_PRESOLVING
149 * - \ref SCIP_STAGE_EXITPRESOLVE
150 * - \ref SCIP_STAGE_PRESOLVED
151 * - \ref SCIP_STAGE_INITSOLVE
152 * - \ref SCIP_STAGE_SOLVING
153 * - \ref SCIP_STAGE_SOLVED
154 * - \ref SCIP_STAGE_EXITSOLVE
155 * - \ref SCIP_STAGE_FREETRANS
156 */
158 SCIP* scip /**< SCIP data structure */
159 )
160{
161 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNReoptRuns", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
162
163 return scip->stat->nreoptruns;
164}
165
166/** add given number to the number of processed nodes in current run and in all runs, including the focus node
167 *
168 * @return the number of processed nodes in current run, including the focus node
169 *
170 * @pre This method can be called if SCIP is in one of the following stages:
171 * - \ref SCIP_STAGE_PROBLEM
172 * - \ref SCIP_STAGE_TRANSFORMING
173 * - \ref SCIP_STAGE_TRANSFORMED
174 * - \ref SCIP_STAGE_INITPRESOLVE
175 * - \ref SCIP_STAGE_PRESOLVING
176 * - \ref SCIP_STAGE_EXITPRESOLVE
177 * - \ref SCIP_STAGE_PRESOLVED
178 * - \ref SCIP_STAGE_INITSOLVE
179 * - \ref SCIP_STAGE_SOLVING
180 * - \ref SCIP_STAGE_SOLVED
181 * - \ref SCIP_STAGE_EXITSOLVE
182 * - \ref SCIP_STAGE_FREETRANS
183 */
185 SCIP* scip, /**< SCIP data structure */
186 SCIP_Longint nnodes /**< number of processed nodes to add to the statistics */
187 )
188{
190
191 scip->stat->nnodes += nnodes;
192 scip->stat->ntotalnodes += nnodes;
193}
194
195/** gets number of processed nodes in current run, including the focus node
196 *
197 * @return the number of processed nodes in current run, including the focus node
198 *
199 * @pre This method can be called if SCIP is in one of the following stages:
200 * - \ref SCIP_STAGE_PROBLEM
201 * - \ref SCIP_STAGE_TRANSFORMING
202 * - \ref SCIP_STAGE_TRANSFORMED
203 * - \ref SCIP_STAGE_INITPRESOLVE
204 * - \ref SCIP_STAGE_PRESOLVING
205 * - \ref SCIP_STAGE_EXITPRESOLVE
206 * - \ref SCIP_STAGE_PRESOLVED
207 * - \ref SCIP_STAGE_INITSOLVE
208 * - \ref SCIP_STAGE_SOLVING
209 * - \ref SCIP_STAGE_SOLVED
210 * - \ref SCIP_STAGE_EXITSOLVE
211 * - \ref SCIP_STAGE_FREETRANS
212 */
213SCIP_Longint SCIPgetNNodes(
214 SCIP* scip /**< SCIP data structure */
215 )
216{
218
219 return scip->stat->nnodes;
220}
221
222/** gets total number of processed nodes in all runs, including the focus node
223 *
224 * @return the total number of processed nodes in all runs, including the focus node
225 *
226 * @pre This method can be called if SCIP is in one of the following stages:
227 * - \ref SCIP_STAGE_PROBLEM
228 * - \ref SCIP_STAGE_TRANSFORMING
229 * - \ref SCIP_STAGE_TRANSFORMED
230 * - \ref SCIP_STAGE_INITPRESOLVE
231 * - \ref SCIP_STAGE_PRESOLVING
232 * - \ref SCIP_STAGE_EXITPRESOLVE
233 * - \ref SCIP_STAGE_PRESOLVED
234 * - \ref SCIP_STAGE_INITSOLVE
235 * - \ref SCIP_STAGE_SOLVING
236 * - \ref SCIP_STAGE_SOLVED
237 * - \ref SCIP_STAGE_EXITSOLVE
238 * - \ref SCIP_STAGE_FREETRANS
239 */
241 SCIP* scip /**< SCIP data structure */
242 )
243{
244 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNTotalNodes", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
245
246 return scip->stat->ntotalnodes;
247}
248
249/** gets number of leaf nodes processed with feasible relaxation solution
250 *
251 * @return number of leaf nodes processed with feasible relaxation solution
252 *
253 * @pre This method can be called if SCIP is in one of the following stages:
254 * - \ref SCIP_STAGE_PROBLEM
255 * - \ref SCIP_STAGE_TRANSFORMING
256 * - \ref SCIP_STAGE_TRANSFORMED
257 * - \ref SCIP_STAGE_INITPRESOLVE
258 * - \ref SCIP_STAGE_PRESOLVING
259 * - \ref SCIP_STAGE_EXITPRESOLVE
260 * - \ref SCIP_STAGE_PRESOLVED
261 * - \ref SCIP_STAGE_INITSOLVE
262 * - \ref SCIP_STAGE_SOLVING
263 * - \ref SCIP_STAGE_SOLVED
264 * - \ref SCIP_STAGE_EXITSOLVE
265 * - \ref SCIP_STAGE_FREETRANS
266 */
268 SCIP* scip /**< SCIP data structure */
269 )
270{
271 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNFeasibleLeaves", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
272
273 return scip->stat->nfeasleaves;
274}
275
276/** gets number of infeasible leaf nodes processed
277 *
278 * @return number of infeasible leaf nodes processed
279 *
280 * @pre This method can be called if SCIP is in one of the following stages:
281 * - \ref SCIP_STAGE_PROBLEM
282 * - \ref SCIP_STAGE_TRANSFORMING
283 * - \ref SCIP_STAGE_TRANSFORMED
284 * - \ref SCIP_STAGE_INITPRESOLVE
285 * - \ref SCIP_STAGE_PRESOLVING
286 * - \ref SCIP_STAGE_EXITPRESOLVE
287 * - \ref SCIP_STAGE_PRESOLVED
288 * - \ref SCIP_STAGE_INITSOLVE
289 * - \ref SCIP_STAGE_SOLVING
290 * - \ref SCIP_STAGE_SOLVED
291 * - \ref SCIP_STAGE_EXITSOLVE
292 * - \ref SCIP_STAGE_FREETRANS
293 */
295 SCIP* scip /**< SCIP data structure */
296 )
297{
298 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNInfeasibleLeaves", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
299
300 return scip->stat->ninfeasleaves;
301}
302
303/** gets number of processed leaf nodes that hit LP objective limit
304 *
305 * @return number of processed leaf nodes that hit LP objective limit
306 *
307 * @pre This method can be called if SCIP is in one of the following stages:
308 * - \ref SCIP_STAGE_PROBLEM
309 * - \ref SCIP_STAGE_TRANSFORMING
310 * - \ref SCIP_STAGE_TRANSFORMED
311 * - \ref SCIP_STAGE_INITPRESOLVE
312 * - \ref SCIP_STAGE_PRESOLVING
313 * - \ref SCIP_STAGE_EXITPRESOLVE
314 * - \ref SCIP_STAGE_PRESOLVED
315 * - \ref SCIP_STAGE_INITSOLVE
316 * - \ref SCIP_STAGE_SOLVING
317 * - \ref SCIP_STAGE_SOLVED
318 * - \ref SCIP_STAGE_EXITSOLVE
319 * - \ref SCIP_STAGE_FREETRANS
320 */
322 SCIP* scip /**< Scip data structure */
323 )
324{
325 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNObjlimLeaves", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
326
327 return scip->stat->nobjleaves;
328}
329
330/** gets number of global bound changes
331 *
332 * @return number of global bound changes
333 *
334 * @pre This method can be called if SCIP is in one of the following stages:
335 * - \ref SCIP_STAGE_PROBLEM
336 * - \ref SCIP_STAGE_TRANSFORMING
337 * - \ref SCIP_STAGE_TRANSFORMED
338 * - \ref SCIP_STAGE_INITPRESOLVE
339 * - \ref SCIP_STAGE_PRESOLVING
340 * - \ref SCIP_STAGE_EXITPRESOLVE
341 * - \ref SCIP_STAGE_PRESOLVED
342 * - \ref SCIP_STAGE_INITSOLVE
343 * - \ref SCIP_STAGE_SOLVING
344 * - \ref SCIP_STAGE_SOLVED
345 * - \ref SCIP_STAGE_EXITSOLVE
346 * - \ref SCIP_STAGE_FREETRANS
347 */
349 SCIP* scip /**< Scip data structure */
350 )
351{
352 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNRootboundChgs", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
353
354 return scip->stat->nrootboundchgs;
355}
356
357/** gets number of global bound changes applied in the current run
358 *
359 * @return number of global bound changes
360 *
361 * @pre This method can be called if SCIP is in one of the following stages:
362 * - \ref SCIP_STAGE_PROBLEM
363 * - \ref SCIP_STAGE_TRANSFORMING
364 * - \ref SCIP_STAGE_TRANSFORMED
365 * - \ref SCIP_STAGE_INITPRESOLVE
366 * - \ref SCIP_STAGE_PRESOLVING
367 * - \ref SCIP_STAGE_EXITPRESOLVE
368 * - \ref SCIP_STAGE_PRESOLVED
369 * - \ref SCIP_STAGE_INITSOLVE
370 * - \ref SCIP_STAGE_SOLVING
371 * - \ref SCIP_STAGE_SOLVED
372 * - \ref SCIP_STAGE_EXITSOLVE
373 * - \ref SCIP_STAGE_FREETRANS
374 */
376 SCIP* scip /**< Scip data structure */
377 )
378{
379 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNRootboundChgsRun", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
380
381 return scip->stat->nrootboundchgsrun;
382}
383
384/** gets number of times a selected node was from a cut off subtree
385 *
386 * @return number of times a selected node was from a cut off subtree
387 *
388 * @pre This method can be called if SCIP is in one of the following stages:
389 * - \ref SCIP_STAGE_PROBLEM
390 * - \ref SCIP_STAGE_TRANSFORMING
391 * - \ref SCIP_STAGE_TRANSFORMED
392 * - \ref SCIP_STAGE_INITPRESOLVE
393 * - \ref SCIP_STAGE_PRESOLVING
394 * - \ref SCIP_STAGE_EXITPRESOLVE
395 * - \ref SCIP_STAGE_PRESOLVED
396 * - \ref SCIP_STAGE_INITSOLVE
397 * - \ref SCIP_STAGE_SOLVING
398 * - \ref SCIP_STAGE_SOLVED
399 * - \ref SCIP_STAGE_EXITSOLVE
400 * - \ref SCIP_STAGE_FREETRANS
401 */
403 SCIP* scip /**< SCIP data structure */
404 )
405{
406 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNDelayedCutoffs", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
407
408 return scip->stat->ndelayedcutoffs;
409}
410
411/** gets total number of LPs solved so far
412 *
413 * @return the total number of LPs solved so far
414 *
415 * @pre This method can be called if SCIP is in one of the following stages:
416 * - \ref SCIP_STAGE_PROBLEM
417 * - \ref SCIP_STAGE_TRANSFORMING
418 * - \ref SCIP_STAGE_TRANSFORMED
419 * - \ref SCIP_STAGE_INITPRESOLVE
420 * - \ref SCIP_STAGE_PRESOLVING
421 * - \ref SCIP_STAGE_EXITPRESOLVE
422 * - \ref SCIP_STAGE_PRESOLVED
423 * - \ref SCIP_STAGE_INITSOLVE
424 * - \ref SCIP_STAGE_SOLVING
425 * - \ref SCIP_STAGE_SOLVED
426 * - \ref SCIP_STAGE_EXITSOLVE
427 * - \ref SCIP_STAGE_FREETRANS
428 */
429SCIP_Longint SCIPgetNLPs(
430 SCIP* scip /**< SCIP data structure */
431 )
432{
434
435 return scip->stat->nlps;
436}
437
438/** gets total number of iterations used so far in primal and dual simplex and barrier algorithm
439 *
440 * @return the total number of iterations used so far in primal and dual simplex and barrier algorithm
441 *
442 * @pre This method can be called if SCIP is in one of the following stages:
443 * - \ref SCIP_STAGE_PRESOLVING
444 * - \ref SCIP_STAGE_PRESOLVED
445 * - \ref SCIP_STAGE_SOLVING
446 * - \ref SCIP_STAGE_SOLVED
447 */
449 SCIP* scip /**< SCIP data structure */
450 )
451{
453
454 return scip->stat->nlpiterations;
455}
456
457/** gets number of active non-zeros in the current transformed problem
458 *
459 * @return the number of active non-zeros in the current transformed problem
460 *
461 * @pre This method can be called if SCIP is in one of the following stages:
462 * - \ref SCIP_STAGE_PROBLEM
463 * - \ref SCIP_STAGE_TRANSFORMING
464 * - \ref SCIP_STAGE_TRANSFORMED
465 * - \ref SCIP_STAGE_INITPRESOLVE
466 * - \ref SCIP_STAGE_PRESOLVING
467 * - \ref SCIP_STAGE_EXITPRESOLVE
468 * - \ref SCIP_STAGE_PRESOLVED
469 * - \ref SCIP_STAGE_INITSOLVE
470 * - \ref SCIP_STAGE_SOLVING
471 * - \ref SCIP_STAGE_SOLVED
472 * - \ref SCIP_STAGE_EXITSOLVE
473 */
474SCIP_Longint SCIPgetNNZs(
475 SCIP* scip /**< SCIP data structure */
476 )
477{
479
480 return scip->stat->nnz;
481}
482
483/** gets total number of iterations used so far in primal and dual simplex and barrier algorithm for the root node
484 *
485 * @return the total number of iterations used so far in primal and dual simplex and barrier algorithm for the root node
486 *
487 * @pre This method can be called if SCIP is in one of the following stages:
488 * - \ref SCIP_STAGE_PRESOLVED
489 * - \ref SCIP_STAGE_SOLVING
490 * - \ref SCIP_STAGE_SOLVED
491 */
493 SCIP* scip /**< SCIP data structure */
494 )
495{
496 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNRootLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
497
498 return scip->stat->nrootlpiterations;
499}
500
501/** gets total number of iterations used in primal and dual simplex and barrier algorithm for the first LP at the root
502 * node
503 *
504 * @return the total number of iterations used in primal and dual simplex and barrier algorithm for the first root LP
505 *
506 * @pre This method can be called if SCIP is in one of the following stages:
507 * - \ref SCIP_STAGE_PRESOLVED
508 * - \ref SCIP_STAGE_SOLVING
509 * - \ref SCIP_STAGE_SOLVED
510 */
512 SCIP* scip /**< SCIP data structure */
513 )
514{
515 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNRootFirstLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
516
517 return scip->stat->nrootfirstlpiterations;
518}
519
520/** gets total number of primal LPs solved so far
521 *
522 * @return the total number of primal LPs solved so far
523 *
524 * @pre This method can be called if SCIP is in one of the following stages:
525 * - \ref SCIP_STAGE_PRESOLVED
526 * - \ref SCIP_STAGE_SOLVING
527 * - \ref SCIP_STAGE_SOLVED
528 */
529SCIP_Longint SCIPgetNPrimalLPs(
530 SCIP* scip /**< SCIP data structure */
531 )
532{
534
535 return scip->stat->nprimallps;
536}
537
538/** gets total number of iterations used so far in primal simplex
539 *
540 * @return total number of iterations used so far in primal simplex
541 *
542 * @pre This method can be called if SCIP is in one of the following stages:
543 * - \ref SCIP_STAGE_PRESOLVED
544 * - \ref SCIP_STAGE_SOLVING
545 * - \ref SCIP_STAGE_SOLVED
546 */
548 SCIP* scip /**< SCIP data structure */
549 )
550{
551 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNPrimalLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
552
553 return scip->stat->nprimallpiterations;
554}
555
556/** gets total number of dual LPs solved so far
557 *
558 * @return the total number of dual LPs solved so far
559 *
560 * @pre This method can be called if SCIP is in one of the following stages:
561 * - \ref SCIP_STAGE_PRESOLVED
562 * - \ref SCIP_STAGE_SOLVING
563 * - \ref SCIP_STAGE_SOLVED
564 */
565SCIP_Longint SCIPgetNDualLPs(
566 SCIP* scip /**< SCIP data structure */
567 )
568{
570
571 return scip->stat->nduallps;
572}
573
574/** gets total number of iterations used so far in dual simplex
575 *
576 * @return the total number of iterations used so far in dual simplex
577 *
578 * @pre This method can be called if SCIP is in one of the following stages:
579 * - \ref SCIP_STAGE_PRESOLVED
580 * - \ref SCIP_STAGE_SOLVING
581 * - \ref SCIP_STAGE_SOLVED
582 */
584 SCIP* scip /**< SCIP data structure */
585 )
586{
587 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNDualLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
588
589 return scip->stat->nduallpiterations;
590}
591
592/** gets total number of barrier LPs solved so far
593 *
594 * @return the total number of barrier LPs solved so far
595 *
596 * @pre This method can be called if SCIP is in one of the following stages:
597 * - \ref SCIP_STAGE_PRESOLVED
598 * - \ref SCIP_STAGE_SOLVING
599 * - \ref SCIP_STAGE_SOLVED
600 */
602 SCIP* scip /**< SCIP data structure */
603 )
604{
606
607 return scip->stat->nbarrierlps;
608}
609
610/** gets total number of iterations used so far in barrier algorithm
611 *
612 * @return the total number of iterations used so far in barrier algorithm
613 *
614 * @pre This method can be called if SCIP is in one of the following stages:
615 * - \ref SCIP_STAGE_PRESOLVED
616 * - \ref SCIP_STAGE_SOLVING
617 * - \ref SCIP_STAGE_SOLVED
618 */
620 SCIP* scip /**< SCIP data structure */
621 )
622{
623 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNBarrierLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
624
625 return scip->stat->nbarrierlpiterations;
626}
627
628/** gets total number of LPs solved so far that were resolved from an advanced start basis
629 *
630 * @return the total number of LPs solved so far that were resolved from an advanced start basis
631 *
632 * @pre This method can be called if SCIP is in one of the following stages:
633 * - \ref SCIP_STAGE_PRESOLVED
634 * - \ref SCIP_STAGE_SOLVING
635 * - \ref SCIP_STAGE_SOLVED
636 */
638 SCIP* scip /**< SCIP data structure */
639 )
640{
642
643 return scip->stat->nprimalresolvelps + scip->stat->ndualresolvelps;
644}
645
646/** gets total number of simplex iterations used so far in primal and dual simplex calls where an advanced start basis
647 * was available
648 *
649 * @return the total number of simplex iterations used so far in primal and dual simplex calls where an advanced start
650 * basis was available
651 *
652 * @pre This method can be called if SCIP is in one of the following stages:
653 * - \ref SCIP_STAGE_PRESOLVED
654 * - \ref SCIP_STAGE_SOLVING
655 * - \ref SCIP_STAGE_SOLVED
656 */
658 SCIP* scip /**< SCIP data structure */
659 )
660{
661 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNResolveLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
662
663 return scip->stat->nprimalresolvelpiterations + scip->stat->ndualresolvelpiterations;
664}
665
666/** gets total number of primal LPs solved so far that were resolved from an advanced start basis
667 *
668 * @return the total number of primal LPs solved so far that were resolved from an advanced start basis
669 *
670 * @pre This method can be called if SCIP is in one of the following stages:
671 * - \ref SCIP_STAGE_PRESOLVED
672 * - \ref SCIP_STAGE_SOLVING
673 * - \ref SCIP_STAGE_SOLVED
674 */
676 SCIP* scip /**< SCIP data structure */
677 )
678{
679 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNPrimalResolveLPs", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
680
681 return scip->stat->nprimalresolvelps;
682}
683
684/** gets total number of simplex iterations used so far in primal simplex calls where an advanced start basis
685 * was available
686 *
687 * @return the total number of simplex iterations used so far in primal simplex calls where an advanced start
688 * basis was available
689 *
690 * @pre This method can be called if SCIP is in one of the following stages:
691 * - \ref SCIP_STAGE_PRESOLVED
692 * - \ref SCIP_STAGE_SOLVING
693 * - \ref SCIP_STAGE_SOLVED
694 */
696 SCIP* scip /**< SCIP data structure */
697 )
698{
699 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNPrimalResolveLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
700
701 return scip->stat->nprimalresolvelpiterations;
702}
703
704/** gets total number of dual LPs solved so far that were resolved from an advanced start basis
705 *
706 * @return the total number of dual LPs solved so far that were resolved from an advanced start basis
707 *
708 * @pre This method can be called if SCIP is in one of the following stages:
709 * - \ref SCIP_STAGE_PRESOLVED
710 * - \ref SCIP_STAGE_SOLVING
711 * - \ref SCIP_STAGE_SOLVED
712 */
714 SCIP* scip /**< SCIP data structure */
715 )
716{
718
719 return scip->stat->ndualresolvelps;
720}
721
722/** gets total number of simplex iterations used so far in dual simplex calls where an advanced start basis
723 * was available
724 *
725 * @return the total number of simplex iterations used so far in dual simplex calls where an advanced start
726 * basis was available
727 *
728 * @pre This method can be called if SCIP is in one of the following stages:
729 * - \ref SCIP_STAGE_PRESOLVED
730 * - \ref SCIP_STAGE_SOLVING
731 * - \ref SCIP_STAGE_SOLVED
732 */
734 SCIP* scip /**< SCIP data structure */
735 )
736{
737 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNDualResolveLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
738
739 return scip->stat->ndualresolvelpiterations;
740}
741
742/** gets total number of LPs solved so far for node relaxations
743 *
744 * @return the total number of LPs solved so far for node relaxations
745 *
746 * @pre This method can be called if SCIP is in one of the following stages:
747 * - \ref SCIP_STAGE_PRESOLVED
748 * - \ref SCIP_STAGE_SOLVING
749 * - \ref SCIP_STAGE_SOLVED
750 */
751SCIP_Longint SCIPgetNNodeLPs(
752 SCIP* scip /**< SCIP data structure */
753 )
754{
756
757 return scip->stat->nnodelps;
758}
759
760/** gets total number of LPs solved in 0 iterations for node relaxations
761 *
762 * @return the total number of LPs solved with 0 iteratins for node relaxations
763 *
764 * @pre This method can be called if SCIP is in one of the following stages:
765 * - \ref SCIP_STAGE_PRESOLVED
766 * - \ref SCIP_STAGE_SOLVING
767 * - \ref SCIP_STAGE_SOLVED
768 */
770 SCIP* scip /**< SCIP data structure */
771 )
772{
773 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNNodeZeroIterationLPs", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
774
775 return scip->stat->nnodezeroitlps;
776}
777
778/** gets total number of simplex iterations used so far for node relaxations
779 *
780 * @return the total number of simplex iterations used so far for node relaxations
781 *
782 * @pre This method can be called if SCIP is in one of the following stages:
783 * - \ref SCIP_STAGE_PRESOLVED
784 * - \ref SCIP_STAGE_SOLVING
785 * - \ref SCIP_STAGE_SOLVED
786 */
788 SCIP* scip /**< SCIP data structure */
789 )
790{
791 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNNodeLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
792
793 return scip->stat->nnodelpiterations;
794}
795
796/** gets total number of LPs solved so far for initial LP in node relaxations
797 *
798 * @return the total number of LPs solved so far for initial LP in node relaxations
799 *
800 * @pre This method can be called if SCIP is in one of the following stages:
801 * - \ref SCIP_STAGE_PRESOLVED
802 * - \ref SCIP_STAGE_SOLVING
803 * - \ref SCIP_STAGE_SOLVED
804 */
806 SCIP* scip /**< SCIP data structure */
807 )
808{
810
811 return scip->stat->ninitlps;
812}
813
814/** gets total number of simplex iterations used so far for initial LP in node relaxations
815 *
816 * @return the total number of simplex iterations used so far for initial LP in node relaxations
817 *
818 * @pre This method can be called if SCIP is in one of the following stages:
819 * - \ref SCIP_STAGE_PRESOLVED
820 * - \ref SCIP_STAGE_SOLVING
821 * - \ref SCIP_STAGE_SOLVED
822 */
824 SCIP* scip /**< SCIP data structure */
825 )
826{
827 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNNodeInitLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
828
829 return scip->stat->ninitlpiterations;
830}
831
832/** gets total number of LPs solved so far during diving and probing
833 *
834 * @return total number of LPs solved so far during diving and probing
835 *
836 * @pre This method can be called if SCIP is in one of the following stages:
837 * - \ref SCIP_STAGE_PRESOLVED
838 * - \ref SCIP_STAGE_SOLVING
839 * - \ref SCIP_STAGE_SOLVED
840 */
841SCIP_Longint SCIPgetNDivingLPs(
842 SCIP* scip /**< SCIP data structure */
843 )
844{
846
847 return scip->stat->ndivinglps;
848}
849
850/** gets total number of simplex iterations used so far during diving and probing
851 *
852 * @return the total number of simplex iterations used so far during diving and probing
853 *
854 * @pre This method can be called if SCIP is in one of the following stages:
855 * - \ref SCIP_STAGE_PRESOLVED
856 * - \ref SCIP_STAGE_SOLVING
857 * - \ref SCIP_STAGE_SOLVED
858 */
860 SCIP* scip /**< SCIP data structure */
861 )
862{
863 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNDivingLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
864
865 return scip->stat->ndivinglpiterations;
866}
867
868/** gets total number of times, strong branching was called (each call represents solving two LPs)
869 *
870 * @return the total number of times, strong branching was called (each call represents solving two LPs)
871 *
872 * @pre This method can be called if SCIP is in one of the following stages:
873 * - \ref SCIP_STAGE_PRESOLVED
874 * - \ref SCIP_STAGE_SOLVING
875 * - \ref SCIP_STAGE_SOLVED
876 */
878 SCIP* scip /**< SCIP data structure */
879 )
880{
882
883 return scip->stat->nstrongbranchs;
884}
885
886/** gets total number of simplex iterations used so far in strong branching
887 *
888 * @return the total number of simplex iterations used so far in strong branching
889 *
890 * @pre This method can be called if SCIP is in one of the following stages:
891 * - \ref SCIP_STAGE_PRESOLVED
892 * - \ref SCIP_STAGE_SOLVING
893 * - \ref SCIP_STAGE_SOLVED
894 */
896 SCIP* scip /**< SCIP data structure */
897 )
898{
899 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNStrongbranchLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
900
901 return scip->stat->nsblpiterations;
902}
903
904/** gets total number of times, strong branching was called at the root node (each call represents solving two LPs)
905 *
906 * @return the total number of times, strong branching was called at the root node (each call represents solving two LPs)
907 *
908 * @pre This method can be called if SCIP is in one of the following stages:
909 * - \ref SCIP_STAGE_PRESOLVED
910 * - \ref SCIP_STAGE_SOLVING
911 * - \ref SCIP_STAGE_SOLVED
912 */
914 SCIP* scip /**< SCIP data structure */
915 )
916{
917 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNRootStrongbranchs", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
918
919 return scip->stat->nrootstrongbranchs;
920}
921
922/** gets total number of simplex iterations used so far in strong branching at the root node
923 *
924 * @return the total number of simplex iterations used so far in strong branching at the root node
925 *
926 * @pre This method can be called if SCIP is in one of the following stages:
927 * - \ref SCIP_STAGE_PRESOLVED
928 * - \ref SCIP_STAGE_SOLVING
929 * - \ref SCIP_STAGE_SOLVED
930 */
932 SCIP* scip /**< SCIP data structure */
933 )
934{
935 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNRootStrongbranchLPIterations", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
936
937 return scip->stat->nrootsblpiterations;
938}
939
940/** gets number of pricing rounds performed so far at the current node
941 *
942 * @return the number of pricing rounds performed so far at the current node
943 *
944 * @pre This method can be called if SCIP is in one of the following stages:
945 * - \ref SCIP_STAGE_SOLVING
946 */
948 SCIP* scip /**< SCIP data structure */
949 )
950{
952
953 return scip->stat->npricerounds;
954}
955
956/** get current number of variables in the pricing store
957 *
958 * @return the current number of variables in the pricing store
959 *
960 * @pre This method can be called if SCIP is in one of the following stages:
961 * - \ref SCIP_STAGE_PRESOLVED
962 * - \ref SCIP_STAGE_SOLVING
963 * - \ref SCIP_STAGE_SOLVED
964 */
966 SCIP* scip /**< SCIP data structure */
967 )
968{
970
971 return scip->pricestore == NULL ? 0 : SCIPpricestoreGetNVars(scip->pricestore);
972}
973
974/** get total number of pricing variables found so far
975 *
976 * @return the total number of pricing variables found so far
977 *
978 * @pre This method can be called if SCIP is in one of the following stages:
979 * - \ref SCIP_STAGE_PRESOLVED
980 * - \ref SCIP_STAGE_SOLVING
981 * - \ref SCIP_STAGE_SOLVED
982 */
984 SCIP* scip /**< SCIP data structure */
985 )
986{
988
989 return scip->pricestore == NULL ? 0 : SCIPpricestoreGetNVarsFound(scip->pricestore);
990}
991
992/** get total number of pricing variables applied to the LPs
993 *
994 * @return the total number of pricing variables applied to the LPs
995 *
996 * @pre This method can be called if SCIP is in one of the following stages:
997 * - \ref SCIP_STAGE_PRESOLVED
998 * - \ref SCIP_STAGE_SOLVING
999 * - \ref SCIP_STAGE_SOLVED
1000 */
1002 SCIP* scip /**< SCIP data structure */
1003 )
1004{
1005 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNPricevarsApplied", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1006
1007 return scip->pricestore == NULL ? 0 : SCIPpricestoreGetNVarsApplied(scip->pricestore);
1008}
1009
1010/** gets number of separation rounds performed so far at the current node
1011 *
1012 * @return the number of separation rounds performed so far at the current node
1013 *
1014 * @pre This method can be called if SCIP is in one of the following stages:
1015 * - \ref SCIP_STAGE_SOLVING
1016 */
1018 SCIP* scip /**< SCIP data structure */
1019 )
1020{
1022
1023 return scip->stat->nseparounds;
1024}
1025
1026/** get total number of cuts added to the sepastore so far; this includes global cuts from the cut pool as often as they are separated
1027 *
1028 * @return the total number of cuts added to the sepastore so far
1029 *
1030 * @pre This method can be called if SCIP is in one of the following stages:
1031 * - \ref SCIP_STAGE_PRESOLVED
1032 * - \ref SCIP_STAGE_SOLVING
1033 * - \ref SCIP_STAGE_SOLVED
1034 */
1036 SCIP* scip /**< SCIP data structure */
1037 )
1038{
1040
1041 return scip->sepastore == NULL ? 0 : SCIPsepastoreGetNCutsAdded(scip->sepastore);
1042}
1043
1044/** get number of cuts found so far in current separation round
1045 *
1046 * @return the number of cuts found so far in current separation round
1047 *
1048 * @pre This method can be called if SCIP is in one of the following stages:
1049 * - \ref SCIP_STAGE_PRESOLVED
1050 * - \ref SCIP_STAGE_SOLVING
1051 * - \ref SCIP_STAGE_SOLVED
1052 */
1054 SCIP* scip /**< SCIP data structure */
1055 )
1056{
1057 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNCutsFoundRound", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1058
1059 return scip->sepastore == NULL ? 0 : SCIPsepastoreGetNCutsFoundRound(scip->sepastore);
1060}
1061
1062/** get total number of cuts applied to the LPs
1063 *
1064 * @return the total number of cuts applied to the LPs
1065 *
1066 * @pre This method can be called if SCIP is in one of the following stages:
1067 * - \ref SCIP_STAGE_PRESOLVED
1068 * - \ref SCIP_STAGE_SOLVING
1069 * - \ref SCIP_STAGE_SOLVED
1070 */
1072 SCIP* scip /**< SCIP data structure */
1073 )
1074{
1076
1077 return scip->sepastore == NULL ? 0 : SCIPsepastoreGetNCutsApplied(scip->sepastore);
1078}
1079
1080/** get total number of constraints found in conflict analysis (conflict, reconvergence constraints, and dual proofs)
1081 *
1082 * @return the total number of constraints found in conflict analysis (conflict, reconvergence constraints, and dual proofs)
1083 *
1084 * @pre This method can be called if SCIP is in one of the following stages:
1085 * - \ref SCIP_STAGE_TRANSFORMED
1086 * - \ref SCIP_STAGE_INITPRESOLVE
1087 * - \ref SCIP_STAGE_PRESOLVING
1088 * - \ref SCIP_STAGE_EXITPRESOLVE
1089 * - \ref SCIP_STAGE_PRESOLVED
1090 * - \ref SCIP_STAGE_INITSOLVE
1091 * - \ref SCIP_STAGE_SOLVING
1092 * - \ref SCIP_STAGE_SOLVED
1093 * - \ref SCIP_STAGE_EXITSOLVE
1094 */
1114
1115/** get number of conflict constraints found so far at the current node
1116 *
1117 * @return the number of conflict constraints found so far at the current node
1118 *
1119 * @pre This method can be called if SCIP is in one of the following stages:
1120 * - \ref SCIP_STAGE_TRANSFORMED
1121 * - \ref SCIP_STAGE_INITPRESOLVE
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 * - \ref SCIP_STAGE_EXITSOLVE
1129 */
1131 SCIP* scip /**< SCIP data structure */
1132 )
1133{
1134 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNConflictConssFoundNode", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1135
1136 return scip->conflict == NULL ? 0 : SCIPconflictGetNConflicts(scip->conflict);
1137}
1138
1139/** get total number of conflict constraints added to the problem
1140 *
1141 * @return the total number of conflict constraints added to the problem
1142 *
1143 * @pre This method can be called if SCIP is in one of the following stages:
1144 * - \ref SCIP_STAGE_TRANSFORMED
1145 * - \ref SCIP_STAGE_INITPRESOLVE
1146 * - \ref SCIP_STAGE_PRESOLVING
1147 * - \ref SCIP_STAGE_EXITPRESOLVE
1148 * - \ref SCIP_STAGE_PRESOLVED
1149 * - \ref SCIP_STAGE_INITSOLVE
1150 * - \ref SCIP_STAGE_SOLVING
1151 * - \ref SCIP_STAGE_SOLVED
1152 * - \ref SCIP_STAGE_EXITSOLVE
1153 */
1155 SCIP* scip /**< SCIP data structure */
1156 )
1157{
1158 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNConflictConssApplied", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1159
1160 return scip->conflict == NULL ? 0 : SCIPconflictGetNAppliedConss(scip->conflict);
1161}
1162
1163/** get total number of dual proof constraints added to the problem
1164 *
1165 * @return the total number of dual proof constraints added to the problem
1166 *
1167 * @pre This method can be called if SCIP is in one of the following stages:
1168 * - \ref SCIP_STAGE_TRANSFORMED
1169 * - \ref SCIP_STAGE_INITPRESOLVE
1170 * - \ref SCIP_STAGE_PRESOLVING
1171 * - \ref SCIP_STAGE_EXITPRESOLVE
1172 * - \ref SCIP_STAGE_PRESOLVED
1173 * - \ref SCIP_STAGE_INITSOLVE
1174 * - \ref SCIP_STAGE_SOLVING
1175 * - \ref SCIP_STAGE_SOLVED
1176 * - \ref SCIP_STAGE_EXITSOLVE
1177 */
1179 SCIP* scip /**< SCIP data structure */
1180 )
1181{
1182 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNConflictDualproofsApplied", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1183
1184 return scip->conflict == NULL ? 0 : (SCIPconflictGetNDualproofsInfSuccess(scip->conflict) +
1186}
1187
1188/** gets maximal depth of all processed nodes in current branch and bound run (excluding probing nodes)
1189 *
1190 * @return the maximal depth of all processed nodes in current branch and bound run (excluding probing nodes)
1191 *
1192 * @pre This method can be called if SCIP is in one of the following stages:
1193 * - \ref SCIP_STAGE_TRANSFORMED
1194 * - \ref SCIP_STAGE_INITPRESOLVE
1195 * - \ref SCIP_STAGE_PRESOLVING
1196 * - \ref SCIP_STAGE_EXITPRESOLVE
1197 * - \ref SCIP_STAGE_PRESOLVED
1198 * - \ref SCIP_STAGE_INITSOLVE
1199 * - \ref SCIP_STAGE_SOLVING
1200 * - \ref SCIP_STAGE_SOLVED
1201 * - \ref SCIP_STAGE_EXITSOLVE
1202 */
1204 SCIP* scip /**< SCIP data structure */
1205 )
1206{
1208
1209 return scip->stat->maxdepth;
1210}
1211
1212/** gets maximal depth of all processed nodes over all branch and bound runs
1213 *
1214 * @return the maximal depth of all processed nodes over all branch and bound runs
1215 *
1216 * @pre This method can be called if SCIP is in one of the following stages:
1217 * - \ref SCIP_STAGE_TRANSFORMED
1218 * - \ref SCIP_STAGE_INITPRESOLVE
1219 * - \ref SCIP_STAGE_PRESOLVING
1220 * - \ref SCIP_STAGE_EXITPRESOLVE
1221 * - \ref SCIP_STAGE_PRESOLVED
1222 * - \ref SCIP_STAGE_INITSOLVE
1223 * - \ref SCIP_STAGE_SOLVING
1224 * - \ref SCIP_STAGE_SOLVED
1225 * - \ref SCIP_STAGE_EXITSOLVE
1226 */
1228 SCIP* scip /**< SCIP data structure */
1229 )
1230{
1231 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetMaxTotalDepth", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1232
1233 return scip->stat->maxtotaldepth;
1234}
1235
1236/** gets total number of backtracks, i.e. number of times, the new node was selected from the leaves queue
1237 *
1238 * @return the total number of backtracks, i.e. number of times, the new node was selected from the leaves queue
1239 *
1240 * @pre This method can be called if SCIP is in one of the following stages:
1241 * - \ref SCIP_STAGE_TRANSFORMED
1242 * - \ref SCIP_STAGE_INITPRESOLVE
1243 * - \ref SCIP_STAGE_PRESOLVING
1244 * - \ref SCIP_STAGE_EXITPRESOLVE
1245 * - \ref SCIP_STAGE_PRESOLVED
1246 * - \ref SCIP_STAGE_INITSOLVE
1247 * - \ref SCIP_STAGE_SOLVING
1248 * - \ref SCIP_STAGE_SOLVED
1249 * - \ref SCIP_STAGE_EXITSOLVE
1250 */
1252 SCIP* scip /**< SCIP data structure */
1253 )
1254{
1255 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNBacktracks", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1256
1257 return scip->stat->nbacktracks;
1258}
1259
1260/** gets total number of active constraints at the current node
1261 *
1262 * @return the total number of active constraints at the current node
1263 *
1264 * @pre This method can be called if SCIP is in one of the following stages:
1265 * - \ref SCIP_STAGE_INITPRESOLVE
1266 * - \ref SCIP_STAGE_PRESOLVING
1267 * - \ref SCIP_STAGE_EXITPRESOLVE
1268 * - \ref SCIP_STAGE_PRESOLVED
1269 * - \ref SCIP_STAGE_SOLVING
1270 */
1272 SCIP* scip /**< SCIP data structure */
1273 )
1274{
1276
1277 return scip->stat->nactiveconss;
1278}
1279
1280/** gets total number of enabled constraints at the current node
1281 *
1282 * @return the total number of enabled constraints at the current node
1283 *
1284 * @pre This method can be called if SCIP is in one of the following stages:
1285 * - \ref SCIP_STAGE_PRESOLVED
1286 * - \ref SCIP_STAGE_SOLVING
1287 */
1289 SCIP* scip /**< SCIP data structure */
1290 )
1291{
1293
1294 return scip->stat->nenabledconss;
1295}
1296
1297/** gets average dual bound of all unprocessed nodes for original problem
1298 *
1299 * @return the average dual bound of all unprocessed nodes for original problem
1300 *
1301 * @pre This method can be called if SCIP is in one of the following stages:
1302 * - \ref SCIP_STAGE_PRESOLVED
1303 * - \ref SCIP_STAGE_SOLVING
1304 * - \ref SCIP_STAGE_SOLVED
1305 */
1307 SCIP* scip /**< SCIP data structure */
1308 )
1309{
1311
1312 return SCIPprobExternObjval(scip->transprob, scip->origprob, scip->set,
1313 SCIPtreeGetAvgLowerbound(scip->tree, scip->primal->cutoffbound));
1314}
1315
1316/** gets average lower (dual) bound of all unprocessed nodes in transformed problem
1317 *
1318 * @return the average lower (dual) bound of all unprocessed nodes in transformed problem
1319 *
1320 * @pre This method can be called if SCIP is in one of the following stages:
1321 * - \ref SCIP_STAGE_PRESOLVED
1322 * - \ref SCIP_STAGE_SOLVING
1323 * - \ref SCIP_STAGE_SOLVED
1324 */
1326 SCIP* scip /**< SCIP data structure */
1327 )
1328{
1330
1331 return SCIPtreeGetAvgLowerbound(scip->tree, scip->primal->cutoffbound);
1332}
1333
1334/** gets global dual bound
1335 *
1336 * @return the global dual bound
1337 *
1338 * @pre This method can be called if SCIP is in one of the following stages:
1339 * - \ref SCIP_STAGE_TRANSFORMED
1340 * - \ref SCIP_STAGE_INITPRESOLVE
1341 * - \ref SCIP_STAGE_PRESOLVING
1342 * - \ref SCIP_STAGE_EXITPRESOLVE
1343 * - \ref SCIP_STAGE_PRESOLVED
1344 * - \ref SCIP_STAGE_INITSOLVE
1345 * - \ref SCIP_STAGE_SOLVING
1346 * - \ref SCIP_STAGE_SOLVED
1347 * - \ref SCIP_STAGE_EXITSOLVE
1348 */
1350 SCIP* scip /**< SCIP data structure */
1351 )
1352{
1354
1355 /* in case we are in presolving we use the stored dual bound if it exits */
1356 if( scip->set->stage <= SCIP_STAGE_INITSOLVE && scip->transprob->dualbound < SCIP_INVALID )
1357 return scip->transprob->dualbound;
1358
1359 return SCIPprobExternObjval(scip->transprob, scip->origprob, scip->set, SCIPgetLowerbound(scip));
1360}
1361
1362/** gets global lower (dual) bound in transformed problem
1363 *
1364 * @return the global lower (dual) bound in transformed problem
1365 *
1366 * @pre This method can be called if SCIP is in one of the following stages:
1367 * - \ref SCIP_STAGE_TRANSFORMED
1368 * - \ref SCIP_STAGE_INITPRESOLVE
1369 * - \ref SCIP_STAGE_PRESOLVING
1370 * - \ref SCIP_STAGE_EXITPRESOLVE
1371 * - \ref SCIP_STAGE_PRESOLVED
1372 * - \ref SCIP_STAGE_INITSOLVE
1373 * - \ref SCIP_STAGE_SOLVING
1374 * - \ref SCIP_STAGE_SOLVED
1375 */
1377 SCIP* scip /**< SCIP data structure */
1378 )
1379{
1381
1382 if( scip->set->stage <= SCIP_STAGE_INITSOLVE )
1383 return -SCIPinfinity(scip);
1385 {
1386 /* in case we could not prove whether the problem is unbounded or infeasible, we want to terminate with lower
1387 * bound = -inf instead of lower bound = upper bound = +inf also in case we prove that the problem is unbounded,
1388 * it seems to make sense to return with lower bound = -inf, since -infinity is the only valid lower bound
1389 */
1390 return -SCIPinfinity(scip);
1391 }
1393 {
1394 /* SCIPtreeGetLowerbound() should return +inf in the case of infeasibility, but when infeasibility is detected
1395 * during presolving this does not seem to be the case; hence, we treat this case explicitly
1396 */
1397 return SCIPinfinity(scip);
1398 }
1399 else
1400 {
1401 SCIP_Real treelowerbound;
1402
1403 /* it may happen that the remaining tree is empty or all open nodes have a lower bound above the cutoff bound, but
1404 * have not yet been cut off, e.g., when the user calls SCIPgetDualbound() in some event handler; in this case,
1405 * the global lower bound is given by the upper bound value
1406 */
1408
1409 if( treelowerbound < scip->primal->upperbound)
1410 return treelowerbound;
1411 else
1412 return scip->primal->upperbound;
1413 }
1414}
1415
1416/** gets dual bound of the root node for the original problem
1417 *
1418 * @return the dual bound of the root node for the original problem
1419 *
1420 * @pre This method can be called if SCIP is in one of the following stages:
1421 * - \ref SCIP_STAGE_PRESOLVING
1422 * - \ref SCIP_STAGE_EXITPRESOLVE
1423 * - \ref SCIP_STAGE_PRESOLVED
1424 * - \ref SCIP_STAGE_INITSOLVE
1425 * - \ref SCIP_STAGE_SOLVING
1426 * - \ref SCIP_STAGE_SOLVED
1427 */
1429 SCIP* scip /**< SCIP data structure */
1430 )
1431{
1432 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetDualboundRoot", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1433
1434 if( SCIPsetIsInfinity(scip->set, scip->stat->rootlowerbound) )
1435 return SCIPgetPrimalbound(scip);
1436 else
1437 return SCIPprobExternObjval(scip->transprob, scip->origprob, scip->set, scip->stat->rootlowerbound);
1438}
1439
1440/** gets lower (dual) bound in transformed problem of the root node
1441 *
1442 * @return the lower (dual) bound in transformed problem of the root node
1443 *
1444 * @pre This method can be called if SCIP is in one of the following stages:
1445 * - \ref SCIP_STAGE_PRESOLVING
1446 * - \ref SCIP_STAGE_EXITPRESOLVE
1447 * - \ref SCIP_STAGE_PRESOLVED
1448 * - \ref SCIP_STAGE_INITSOLVE
1449 * - \ref SCIP_STAGE_SOLVING
1450 * - \ref SCIP_STAGE_SOLVED
1451 */
1453 SCIP* scip /**< SCIP data structure */
1454 )
1455{
1456 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetLowerboundRoot", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1457
1458 if( SCIPsetIsInfinity(scip->set, scip->stat->rootlowerbound) )
1459 return SCIPgetUpperbound(scip);
1460 else
1461 return scip->stat->rootlowerbound;
1462}
1463
1464/** gets dual bound for the original problem obtained by the first LP solve at the root node
1465 *
1466 * @return the dual bound for the original problem of the first LP solve at the root node
1467 *
1468 * @pre This method can be called if SCIP is in one of the following stages:
1469 * - \ref SCIP_STAGE_PRESOLVING
1470 * - \ref SCIP_STAGE_EXITPRESOLVE
1471 * - \ref SCIP_STAGE_PRESOLVED
1472 * - \ref SCIP_STAGE_INITSOLVE
1473 * - \ref SCIP_STAGE_SOLVING
1474 * - \ref SCIP_STAGE_SOLVED
1475 */
1477 SCIP* scip /**< SCIP data structure */
1478 )
1479{
1480 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetFirstLPDualboundRoot", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1481
1482 return scip->stat->firstlpdualbound;
1483}
1484
1485/** gets lower (dual) bound in transformed problem obtained by the first LP solve at the root node
1486 *
1487 * @return the lower (dual) bound in transformed problem obtained by first LP solve at the root node
1488 *
1489 * @pre This method can be called if SCIP is in one of the following stages:
1490 * - \ref SCIP_STAGE_PRESOLVING
1491 * - \ref SCIP_STAGE_EXITPRESOLVE
1492 * - \ref SCIP_STAGE_PRESOLVED
1493 * - \ref SCIP_STAGE_INITSOLVE
1494 * - \ref SCIP_STAGE_SOLVING
1495 * - \ref SCIP_STAGE_SOLVED
1496 */
1498 SCIP* scip /**< SCIP data structure */
1499 )
1500{
1501 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetFirstLPLowerboundRoot", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1502
1503 if( scip->stat->firstlpdualbound == SCIP_INVALID ) /*lint !e777*/
1504 return -SCIPinfinity(scip);
1505 else
1506 return SCIPprobInternObjval(scip->transprob, scip->origprob, scip->set, scip->stat->firstlpdualbound);
1507}
1508
1509/** the primal bound of the very first solution */
1511 SCIP* scip /**< SCIP data structure */
1512 )
1513{
1514 return scip->stat->firstprimalbound;
1515}
1516
1517/** gets global primal bound (objective value of best solution or user objective limit) for the original problem
1518 *
1519 * @return the global primal bound (objective value of best solution or user objective limit) for the original problem
1520 *
1521 * @pre This method can be called if SCIP is in one of the following stages:
1522 * - \ref SCIP_STAGE_TRANSFORMED
1523 * - \ref SCIP_STAGE_INITPRESOLVE
1524 * - \ref SCIP_STAGE_PRESOLVING
1525 * - \ref SCIP_STAGE_EXITPRESOLVE
1526 * - \ref SCIP_STAGE_PRESOLVED
1527 * - \ref SCIP_STAGE_INITSOLVE
1528 * - \ref SCIP_STAGE_SOLVING
1529 * - \ref SCIP_STAGE_SOLVED
1530 * - \ref SCIP_STAGE_EXITSOLVE
1531 */
1533 SCIP* scip /**< SCIP data structure */
1534 )
1535{
1536 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetPrimalbound", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1537
1538 return SCIPprobExternObjval(scip->transprob, scip->origprob, scip->set, SCIPgetUpperbound(scip));
1539}
1540
1541/** gets global upper (primal) bound in transformed problem (objective value of best solution or user objective limit)
1542 *
1543 * @return the global upper (primal) bound in transformed problem (objective value of best solution or user objective limit)
1544 *
1545 * @pre This method can be called if SCIP is in one of the following stages:
1546 * - \ref SCIP_STAGE_TRANSFORMED
1547 * - \ref SCIP_STAGE_INITPRESOLVE
1548 * - \ref SCIP_STAGE_PRESOLVING
1549 * - \ref SCIP_STAGE_EXITPRESOLVE
1550 * - \ref SCIP_STAGE_PRESOLVED
1551 * - \ref SCIP_STAGE_INITSOLVE
1552 * - \ref SCIP_STAGE_SOLVING
1553 * - \ref SCIP_STAGE_SOLVED
1554 * - \ref SCIP_STAGE_EXITSOLVE
1555 */
1557 SCIP* scip /**< SCIP data structure */
1558 )
1559{
1561
1563 return -SCIPinfinity(scip);
1564 else
1565 return scip->primal->upperbound;
1566}
1567
1568/** gets global cutoff bound in transformed problem: a sub problem with lower bound larger than the cutoff
1569 * cannot contain a better feasible solution; usually, this bound is equal to the upper bound, but if the
1570 * objective value is always integral, the cutoff bound is (nearly) one less than the upper bound;
1571 * additionally, due to objective function domain propagation, the cutoff bound can be further reduced
1572 *
1573 * @return global cutoff bound in transformed problem
1574 *
1575 * @pre This method can be called if SCIP is in one of the following stages:
1576 * - \ref SCIP_STAGE_TRANSFORMED
1577 * - \ref SCIP_STAGE_INITPRESOLVE
1578 * - \ref SCIP_STAGE_PRESOLVING
1579 * - \ref SCIP_STAGE_EXITPRESOLVE
1580 * - \ref SCIP_STAGE_PRESOLVED
1581 * - \ref SCIP_STAGE_INITSOLVE
1582 * - \ref SCIP_STAGE_SOLVING
1583 * - \ref SCIP_STAGE_SOLVED
1584 * - \ref SCIP_STAGE_EXITSOLVE
1585 */
1587 SCIP* scip /**< SCIP data structure */
1588 )
1589{
1590 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetCutoffbound", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1591
1592 return scip->primal->cutoffbound;
1593}
1594
1595/** updates the cutoff bound
1596 *
1597 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1598 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1599 *
1600 * @note using this method in the solving stage can lead to an erroneous SCIP solving status; in particular,
1601 * if a solution not respecting the cutoff bound was found before installing a cutoff bound which
1602 * renders the remaining problem infeasible, this solution may be reported as optimal
1603 *
1604 * @pre This method can be called if SCIP is in one of the following stages:
1605 * - \ref SCIP_STAGE_TRANSFORMED
1606 * - \ref SCIP_STAGE_PRESOLVING
1607 * - \ref SCIP_STAGE_PRESOLVED
1608 * - \ref SCIP_STAGE_INITSOLVE
1609 * - \ref SCIP_STAGE_SOLVING
1610 *
1611 * @note the given cutoff bound has to better or equal to known one (SCIPgetCutoffbound())
1612 * @note a given cutoff bound is also used for updating the objective limit, if possible
1613 */
1615 SCIP* scip, /**< SCIP data structure */
1616 SCIP_Real cutoffbound /**< new cutoff bound */
1617 )
1618{
1619 SCIP_CALL( SCIPcheckStage(scip, "SCIPupdateCutoffbound", FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1620
1621 assert(cutoffbound <= SCIPgetCutoffbound(scip));
1622
1623 SCIP_CALL( SCIPprimalSetCutoffbound(scip->primal, scip->mem->probmem, scip->set, scip->stat, scip->eventfilter,
1624 scip->eventqueue, scip->transprob, scip->origprob, scip->tree, scip->reopt, scip->lp, cutoffbound, FALSE) );
1625
1626 return SCIP_OKAY;
1627}
1628
1629
1630/** returns whether the current primal bound is justified with a feasible primal solution; if not, the primal bound
1631 * was set from the user as objective limit
1632 *
1633 * @return TRUE if the current primal bound is justified with a feasible primal solution, otherwise FALSE
1634 *
1635 * @pre This method can be called if SCIP is in one of the following stages:
1636 * - \ref SCIP_STAGE_TRANSFORMED
1637 * - \ref SCIP_STAGE_INITPRESOLVE
1638 * - \ref SCIP_STAGE_PRESOLVING
1639 * - \ref SCIP_STAGE_EXITPRESOLVE
1640 * - \ref SCIP_STAGE_PRESOLVED
1641 * - \ref SCIP_STAGE_INITSOLVE
1642 * - \ref SCIP_STAGE_SOLVING
1643 * - \ref SCIP_STAGE_SOLVED
1644 * - \ref SCIP_STAGE_EXITSOLVE
1645 */
1647 SCIP* scip /**< SCIP data structure */
1648 )
1649{
1650 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPisPrimalboundSol", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1651
1652 return SCIPprimalUpperboundIsSol(scip->primal, scip->set, scip->transprob, scip->origprob);
1653}
1654
1655/** gets current gap |(primalbound - dualbound)/min(|primalbound|,|dualbound|)| if both bounds have same sign,
1656 * or infinity, if they have opposite sign
1657 *
1658 * @return the current gap |(primalbound - dualbound)/min(|primalbound|,|dualbound|)| if both bounds have same sign,
1659 * or infinity, if they have opposite sign
1660 *
1661 * @pre This method can be called if SCIP is in one of the following stages:
1662 * - \ref SCIP_STAGE_PRESOLVING
1663 * - \ref SCIP_STAGE_EXITPRESOLVE
1664 * - \ref SCIP_STAGE_PRESOLVED
1665 * - \ref SCIP_STAGE_INITSOLVE
1666 * - \ref SCIP_STAGE_SOLVING
1667 * - \ref SCIP_STAGE_SOLVED
1668 */
1669SCIP_Real SCIPgetGap(
1670 SCIP* scip /**< SCIP data structure */
1671 )
1672{
1674
1675 /* in case we could not prove whether the problem is unbounded or infeasible, we want to terminate with gap = +inf;
1676 * if the problem was proven to be unbounded or proven to be infeasible we return gap = 0
1677 */
1679 return SCIPsetInfinity(scip->set);
1681 return 0.0;
1682
1683 /* the lowerbound is infinity, but SCIP may not have updated the status; in this case, the problem was already solved
1684 * so we return gap = 0
1685 */
1687 return 0.0;
1688
1690}
1691
1692/** gets current gap |(upperbound - lowerbound)/min(|upperbound|,|lowerbound|)| in transformed problem if both bounds
1693 * have same sign, or infinity, if they have opposite sign
1694 *
1695 * @return current gap |(upperbound - lowerbound)/min(|upperbound|,|lowerbound|)| in transformed problem if both bounds
1696 * have same sign, or infinity, if they have opposite sign
1697 *
1698 * @pre This method can be called if SCIP is in one of the following stages:
1699 * - \ref SCIP_STAGE_PRESOLVED
1700 * - \ref SCIP_STAGE_SOLVING
1701 * - \ref SCIP_STAGE_SOLVED
1702 */
1704 SCIP* scip /**< SCIP data structure */
1705 )
1706{
1708
1709 /* in case we could not prove whether the problem is unbounded or infeasible, we want to terminate with gap = +inf;
1710 * if the problem was proven to be unbounded or proven to be infeasible we return gap = 0
1711 */
1713 return SCIPsetInfinity(scip->set);
1715 return 0.0;
1716
1717 /* the lowerbound is infinity, but SCIP may not have updated the status; in this case, the problem was already solved
1718 * so we return gap = 0
1719 */
1721 return 0.0;
1722
1724}
1725
1726/** gets number of feasible primal solutions found so far
1727 *
1728 * @return the number of feasible primal solutions found so far
1729 *
1730 * @pre This method can be called if SCIP is in one of the following stages:
1731 * - \ref SCIP_STAGE_TRANSFORMED
1732 * - \ref SCIP_STAGE_INITPRESOLVE
1733 * - \ref SCIP_STAGE_PRESOLVING
1734 * - \ref SCIP_STAGE_EXITPRESOLVE
1735 * - \ref SCIP_STAGE_PRESOLVED
1736 * - \ref SCIP_STAGE_INITSOLVE
1737 * - \ref SCIP_STAGE_SOLVING
1738 * - \ref SCIP_STAGE_SOLVED
1739 * - \ref SCIP_STAGE_EXITSOLVE
1740 */
1742 SCIP* scip /**< SCIP data structure */
1743 )
1744{
1746
1747 return scip->primal->nsolsfound;
1748}
1749
1750/** gets number of feasible primal solutions respecting the objective limit found so far
1751 *
1752 * @return the number of feasible primal solutions respecting the objective limit found so far
1753 *
1754 * @pre This method can be called if SCIP is in one of the following stages:
1755 * - \ref SCIP_STAGE_INIT
1756 * - \ref SCIP_STAGE_PROBLEM
1757 * - \ref SCIP_STAGE_TRANSFORMING
1758 * - \ref SCIP_STAGE_TRANSFORMED
1759 * - \ref SCIP_STAGE_INITPRESOLVE
1760 * - \ref SCIP_STAGE_PRESOLVING
1761 * - \ref SCIP_STAGE_EXITPRESOLVE
1762 * - \ref SCIP_STAGE_PRESOLVED
1763 * - \ref SCIP_STAGE_INITSOLVE
1764 * - \ref SCIP_STAGE_SOLVING
1765 * - \ref SCIP_STAGE_SOLVED
1766 * - \ref SCIP_STAGE_EXITSOLVE
1767 */
1769 SCIP* scip /**< SCIP data structure */
1770 )
1771{
1773 return 0;
1774
1775 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNLimSolsFound", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1776
1777 return scip->primal->nlimsolsfound;
1778}
1779
1780/** gets number of feasible primal solutions found so far, that improved the primal bound at the time they were found
1781 *
1782 * @return the number of feasible primal solutions found so far, that improved the primal bound at the time they were found
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_INITSOLVE
1791 * - \ref SCIP_STAGE_SOLVING
1792 * - \ref SCIP_STAGE_SOLVED
1793 * - \ref SCIP_STAGE_EXITSOLVE
1794 */
1796 SCIP* scip /**< SCIP data structure */
1797 )
1798{
1799 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNBestSolsFound", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
1800
1801 return scip->primal->nbestsolsfound;
1802}
1803
1804/** gets the average pseudo cost value for the given direction over all variables
1805 *
1806 * @return the average pseudo cost value for the given direction over all variables
1807 *
1808 * @pre This method can be called if SCIP is in one of the following stages:
1809 * - \ref SCIP_STAGE_SOLVING
1810 * - \ref SCIP_STAGE_SOLVED
1811 */
1813 SCIP* scip, /**< SCIP data structure */
1814 SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
1815 )
1816{
1818
1819 return SCIPhistoryGetPseudocost(scip->stat->glbhistory, solvaldelta);
1820}
1821
1822/** gets the average pseudo cost value for the given direction over all variables,
1823 * only using the pseudo cost information of the current run
1824 *
1825 * @return the average pseudo cost value for the given direction over all variables,
1826 * only using the pseudo cost information of the current run
1827 *
1828 * @pre This method can be called if SCIP is in one of the following stages:
1829 * - \ref SCIP_STAGE_SOLVING
1830 * - \ref SCIP_STAGE_SOLVED
1831 */
1833 SCIP* scip, /**< SCIP data structure */
1834 SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
1835 )
1836{
1837 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgPseudocostCurrentRun", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1838
1839 return SCIPhistoryGetPseudocost(scip->stat->glbhistorycrun, solvaldelta);
1840}
1841
1842/** gets the average number of pseudo cost updates for the given direction over all variables
1843 *
1844 * @return the average number of pseudo cost updates for the given direction over all variables
1845 *
1846 * @pre This method can be called if SCIP is in one of the following stages:
1847 * - \ref SCIP_STAGE_SOLVING
1848 * - \ref SCIP_STAGE_SOLVED
1849 */
1851 SCIP* scip, /**< SCIP data structure */
1852 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1853 )
1854{
1855 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgPseudocostCount", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1856
1857 return SCIPhistoryGetPseudocostCount(scip->stat->glbhistory, dir)
1858 / MAX(scip->transprob->nbinvars + scip->transprob->nintvars, 1);
1859}
1860
1861/** gets the average number of pseudo cost updates for the given direction over all variables,
1862 * only using the pseudo cost information of the current run
1863 *
1864 * @return the average number of pseudo cost updates for the given direction over all variables,
1865 * only using the pseudo cost information of the current run
1866 *
1867 * @pre This method can be called if SCIP is in one of the following stages:
1868 * - \ref SCIP_STAGE_SOLVING
1869 * - \ref SCIP_STAGE_SOLVED
1870 */
1872 SCIP* scip, /**< SCIP data structure */
1873 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1874 )
1875{
1876 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgPseudocostCountCurrentRun", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1877
1878 return SCIPhistoryGetPseudocostCount(scip->stat->glbhistorycrun, dir)
1879 / MAX(scip->transprob->nbinvars + scip->transprob->nintvars, 1);
1880}
1881
1882/** gets the average pseudo cost score value over all variables, assuming a fractionality of 0.5
1883 *
1884 * @return the average pseudo cost score value over all variables, assuming a fractionality of 0.5
1885 *
1886 * @pre This method can be called if SCIP is in one of the following stages:
1887 * - \ref SCIP_STAGE_SOLVING
1888 * - \ref SCIP_STAGE_SOLVED
1889 */
1891 SCIP* scip /**< SCIP data structure */
1892 )
1893{
1894 SCIP_Real pscostdown;
1895 SCIP_Real pscostup;
1896
1897 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgPseudocostScore", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1898
1899 pscostdown = SCIPhistoryGetPseudocost(scip->stat->glbhistory, -0.5);
1900 pscostup = SCIPhistoryGetPseudocost(scip->stat->glbhistory, +0.5);
1901
1903}
1904
1905/** returns the variance of pseudo costs for all variables in the requested direction
1906 *
1907 * @return the variance of pseudo costs for all variables in the requested direction
1908 *
1909 * @pre This method can be called if SCIP is in one of the following stages:
1910 * - \ref SCIP_STAGE_SOLVING
1911 * - \ref SCIP_STAGE_SOLVED
1912 */
1914 SCIP* scip, /**< SCIP data structure */
1915 SCIP_BRANCHDIR branchdir, /**< the branching direction, up or down */
1916 SCIP_Bool onlycurrentrun /**< use only history of current run? */
1917 )
1918{
1919 SCIP_HISTORY* history;
1920
1921 assert(scip != NULL);
1922 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetPseudocostVariance", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1923
1924 history = (onlycurrentrun ? scip->stat->glbhistorycrun : scip->stat->glbhistory);
1925 assert(history != NULL);
1926
1928}
1929
1930/** gets the number of pseudo cost updates for the given direction over all variables
1931 *
1932 * @return the number of pseudo cost updates for the given direction over all variables
1933 *
1934 * @pre This method can be called if SCIP is in one of the following stages:
1935 * - \ref SCIP_STAGE_SOLVING
1936 * - \ref SCIP_STAGE_SOLVED
1937 */
1939 SCIP* scip, /**< SCIP data structure */
1940 SCIP_BRANCHDIR dir, /**< branching direction (downwards, or upwards) */
1941 SCIP_Bool onlycurrentrun /**< use only history of current run? */
1942 )
1943{
1944 SCIP_HISTORY* history;
1945
1946 assert(scip != NULL);
1948
1949 history = (onlycurrentrun ? scip->stat->glbhistorycrun : scip->stat->glbhistory);
1950
1951 return SCIPhistoryGetPseudocostCount(history, dir);
1952}
1953
1954/** gets the average pseudo cost score value over all variables, assuming a fractionality of 0.5,
1955 * only using the pseudo cost information of the current run
1956 *
1957 * @return the average pseudo cost score value over all variables, assuming a fractionality of 0.5,
1958 * only using the pseudo cost information of the current run
1959 *
1960 * @pre This method can be called if SCIP is in one of the following stages:
1961 * - \ref SCIP_STAGE_SOLVING
1962 * - \ref SCIP_STAGE_SOLVED
1963 */
1965 SCIP* scip /**< SCIP data structure */
1966 )
1967{
1968 SCIP_Real pscostdown;
1969 SCIP_Real pscostup;
1970
1971 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgPseudocostScoreCurrentRun", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1972
1973 pscostdown = SCIPhistoryGetPseudocost(scip->stat->glbhistorycrun, -0.5);
1974 pscostup = SCIPhistoryGetPseudocost(scip->stat->glbhistorycrun, +0.5);
1975
1977}
1978
1979/** gets the average conflict score value over all variables
1980 *
1981 * @return the average conflict score value over all variables
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 */
1988 SCIP* scip /**< SCIP data structure */
1989 )
1990{
1991 SCIP_Real conflictscoredown;
1992 SCIP_Real conflictscoreup;
1993 SCIP_Real scale;
1994
1995 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgConflictScore", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1996
1997 scale = scip->transprob->nvars * scip->stat->vsidsweight;
1999 conflictscoreup = SCIPhistoryGetVSIDS(scip->stat->glbhistory, SCIP_BRANCHDIR_UPWARDS) / scale;
2000
2002}
2003
2004/** gets the average conflict score value over all variables, only using the conflict score information of the current run
2005 *
2006 * @return the average conflict score value over all variables, only using the conflict score information of the current run
2007 *
2008 * @pre This method can be called if SCIP is in one of the following stages:
2009 * - \ref SCIP_STAGE_SOLVING
2010 * - \ref SCIP_STAGE_SOLVED
2011 */
2013 SCIP* scip /**< SCIP data structure */
2014 )
2015{
2016 SCIP_Real conflictscoredown;
2017 SCIP_Real conflictscoreup;
2018 SCIP_Real scale;
2019
2020 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgConflictScoreCurrentRun", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2021
2022 scale = scip->transprob->nvars * scip->stat->vsidsweight;
2023 conflictscoredown = SCIPhistoryGetVSIDS(scip->stat->glbhistorycrun, SCIP_BRANCHDIR_DOWNWARDS) / scale;
2024 conflictscoreup = SCIPhistoryGetVSIDS(scip->stat->glbhistorycrun, SCIP_BRANCHDIR_UPWARDS) / scale;
2025
2027}
2028
2029/** gets the average inference score value over all variables
2030 *
2031 * @return the average inference score value over all variables
2032 *
2033 * @pre This method can be called if SCIP is in one of the following stages:
2034 * - \ref SCIP_STAGE_SOLVING
2035 * - \ref SCIP_STAGE_SOLVED
2036 */
2038 SCIP* scip /**< SCIP data structure */
2039 )
2040{
2041 SCIP_Real conflictlengthdown;
2042 SCIP_Real conflictlengthup;
2043
2044 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgConflictlengthScore", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2045
2048
2050}
2051
2052/** gets the average conflictlength score value over all variables, only using the conflictlength information of the
2053 * current run
2054 *
2055 * @return the average conflictlength score value over all variables, only using the conflictlength information of the
2056 * current run
2057 *
2058 * @pre This method can be called if SCIP is in one of the following stages:
2059 * - \ref SCIP_STAGE_SOLVING
2060 * - \ref SCIP_STAGE_SOLVED
2061 */
2063 SCIP* scip /**< SCIP data structure */
2064 )
2065{
2066 SCIP_Real conflictlengthdown;
2067 SCIP_Real conflictlengthup;
2068
2069 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgConflictlengthScoreCurrentRun", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2070
2073
2075}
2076
2077/** returns the average number of inferences found after branching in given direction over all variables
2078 *
2079 * @return the average number of inferences found after branching in given direction over all variables
2080 *
2081 * @pre This method can be called if SCIP is in one of the following stages:
2082 * - \ref SCIP_STAGE_SOLVING
2083 * - \ref SCIP_STAGE_SOLVED
2084 */
2086 SCIP* scip, /**< SCIP data structure */
2087 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
2088 )
2089{
2091
2092 return SCIPhistoryGetAvgInferences(scip->stat->glbhistory, dir);
2093}
2094
2095/** returns the average number of inferences found after branching in given direction over all variables,
2096 * only using the inference information of the current run
2097 *
2098 * @return the average number of inferences found after branching in given direction over all variables,
2099 * only using the inference information of the current run
2100 *
2101 * @pre This method can be called if SCIP is in one of the following stages:
2102 * - \ref SCIP_STAGE_SOLVING
2103 * - \ref SCIP_STAGE_SOLVED
2104 */
2106 SCIP* scip, /**< SCIP data structure */
2107 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
2108 )
2109{
2110 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgInferencesCurrentRun", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2111
2112 return SCIPhistoryGetAvgInferences(scip->stat->glbhistorycrun, dir);
2113}
2114
2115/** gets the average inference score value over all variables
2116 *
2117 * @return the average inference score value over all variables
2118 *
2119 * @pre This method can be called if SCIP is in one of the following stages:
2120 * - \ref SCIP_STAGE_SOLVING
2121 * - \ref SCIP_STAGE_SOLVED
2122 */
2124 SCIP* scip /**< SCIP data structure */
2125 )
2126{
2127 SCIP_Real inferencesdown;
2128 SCIP_Real inferencesup;
2129
2130 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgInferenceScore", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2131
2134
2136}
2137
2138/** gets the average inference score value over all variables, only using the inference information of the
2139 * current run
2140 *
2141 * @return the average inference score value over all variables, only using the inference information of the
2142 * current run
2143 *
2144 * @pre This method can be called if SCIP is in one of the following stages:
2145 * - \ref SCIP_STAGE_SOLVING
2146 * - \ref SCIP_STAGE_SOLVED
2147 */
2149 SCIP* scip /**< SCIP data structure */
2150 )
2151{
2152 SCIP_Real inferencesdown;
2153 SCIP_Real inferencesup;
2154
2155 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgInferenceScoreCurrentRun", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2156
2159
2161}
2162
2163/** returns the average number of cutoffs found after branching in given direction over all variables
2164 *
2165 * @return the average number of cutoffs found after branching in given direction over all variables
2166 *
2167 * @pre This method can be called if SCIP is in one of the following stages:
2168 * - \ref SCIP_STAGE_SOLVING
2169 * - \ref SCIP_STAGE_SOLVED
2170 */
2172 SCIP* scip, /**< SCIP data structure */
2173 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
2174 )
2175{
2177
2178 return SCIPhistoryGetAvgCutoffs(scip->stat->glbhistory, dir);
2179}
2180
2181/** returns the average number of cutoffs found after branching in given direction over all variables,
2182 * only using the cutoff information of the current run
2183 *
2184 * @return the average number of cutoffs found after branching in given direction over all variables,
2185 * only using the cutoff information of the current run
2186 *
2187 * @pre This method can be called if SCIP is in one of the following stages:
2188 * - \ref SCIP_STAGE_SOLVING
2189 * - \ref SCIP_STAGE_SOLVED
2190 */
2192 SCIP* scip, /**< SCIP data structure */
2193 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
2194 )
2195{
2196 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgCutoffsCurrentRun", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2197
2198 return SCIPhistoryGetAvgCutoffs(scip->stat->glbhistorycrun, dir);
2199}
2200
2201/** gets the average cutoff score value over all variables
2202 *
2203 * @return the average cutoff score value over all variables
2204 *
2205 * @pre This method can be called if SCIP is in one of the following stages:
2206 * - \ref SCIP_STAGE_SOLVING
2207 * - \ref SCIP_STAGE_SOLVED
2208 */
2210 SCIP* scip /**< SCIP data structure */
2211 )
2212{
2213 SCIP_Real cutoffsdown;
2214 SCIP_Real cutoffsup;
2215
2217
2220
2222}
2223
2224/** gets the average cutoff score value over all variables, only using the cutoff score information of the current run
2225 *
2226 * @return the average cutoff score value over all variables, only using the cutoff score information of the current run
2227 *
2228 * @pre This method can be called if SCIP is in one of the following stages:
2229 * - \ref SCIP_STAGE_SOLVING
2230 * - \ref SCIP_STAGE_SOLVED
2231 */
2233 SCIP* scip /**< SCIP data structure */
2234 )
2235{
2236 SCIP_Real cutoffsdown;
2237 SCIP_Real cutoffsup;
2238
2239 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetAvgCutoffScoreCurrentRun", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2240
2243
2245}
2246
2247/** returns the average normalized efficacy of a GMI cut over all variables
2248 *
2249 * @return increases the average normalized efficacy of a GMI cut over all variables
2250 *
2251 * @pre This method can be called if SCIP is in one of the following stages:
2252 * - \ref SCIP_STAGE_SOLVING
2253 * - \ref SCIP_STAGE_SOLVED
2254 */
2256 SCIP* scip, /**< SCIP data structure */
2257 SCIP_Real gmieff /**< average normalized GMI cut efficacy over all variables */
2258 )
2259{
2261
2262 SCIPhistoryIncGMIeffSum(scip->stat->glbhistory, gmieff);
2263}
2264
2265/** Increases the cumulative normalized efficacy of average (over all variables) GMI cuts
2266 *
2267 * @return the average normalized efficacy of a GMI cut over all variables
2268 *
2269 * @pre This method can be called if SCIP is in one of the following stages:
2270 * - \ref SCIP_STAGE_SOLVING
2271 * - \ref SCIP_STAGE_SOLVED
2272 */
2274 SCIP* scip /**< SCIP data structure */
2275 )
2276{
2278
2279 return SCIPhistoryGetAvgGMIeff(scip->stat->glbhistory);
2280}
2281
2282/** computes a deterministic measure of time from statistics
2283 *
2284 * @return the deterministic time
2285 *
2286 * @pre This method can be called if SCIP is in one of the following stages:
2287 * - \ref SCIP_STAGE_PRESOLVING
2288 * - \ref SCIP_STAGE_PRESOLVED
2289 * - \ref SCIP_STAGE_SOLVING
2290 * - \ref SCIP_STAGE_SOLVED
2291 */
2293 SCIP* scip /**< SCIP data structure */
2294 )
2295{
2296/* TODO: SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetDeterministicTime", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) ); */
2297 if(scip->stat == NULL)
2298 return 0.0;
2299
2300 return 1e-6 * scip->stat->nnz * (
2301 0.00328285264101 * scip->stat->nprimalresolvelpiterations +
2302 0.00531625104146 * scip->stat->ndualresolvelpiterations +
2303 0.000738719124051 * scip->stat->nprobboundchgs +
2304 0.0011123144764 * scip->stat->nisstoppedcalls );
2305}
2306
2307/** outputs problem to file stream */
2308static
2310 SCIP* scip, /**< SCIP data structure */
2311 SCIP_PROB* prob, /**< problem data */
2312 FILE* file, /**< output file (or NULL for standard output) */
2313 const char* extension, /**< file format (or NULL for default CIP format) */
2314 SCIP_Bool genericnames /**< using generic variable and constraint names? */
2315 )
2316{
2318 int i;
2319 assert(scip != NULL);
2320 assert(prob != NULL);
2321
2322 /* try all readers until one could read the file */
2324 for( i = 0; i < scip->set->nreaders && result == SCIP_DIDNOTRUN; ++i )
2325 {
2326 SCIP_RETCODE retcode;
2327
2328 if( extension != NULL )
2329 retcode = SCIPreaderWrite(scip->set->readers[i], prob, scip->set, file, extension, genericnames, &result);
2330 else
2331 retcode = SCIPreaderWrite(scip->set->readers[i], prob, scip->set, file, "cip", genericnames, &result);
2332
2333 /* check for reader errors */
2334 if( retcode == SCIP_WRITEERROR )
2335 return retcode;
2336
2337 SCIP_CALL( retcode );
2338 }
2339
2340 switch( result )
2341 {
2342 case SCIP_DIDNOTRUN:
2343 return SCIP_PLUGINNOTFOUND;
2344
2345 case SCIP_SUCCESS:
2346 return SCIP_OKAY;
2347
2348 default:
2349 assert(i < scip->set->nreaders);
2350 SCIPerrorMessage("invalid result code <%d> from reader <%s> writing <%s> format\n",
2351 result, SCIPreaderGetName(scip->set->readers[i]), extension);
2352 return SCIP_READERROR;
2353 } /*lint !e788*/
2354}
2355
2356/** outputs original problem to file stream
2357 *
2358 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2359 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2360 *
2361 * @pre This method can be called if SCIP is in one of the following stages:
2362 * - \ref SCIP_STAGE_PROBLEM
2363 * - \ref SCIP_STAGE_TRANSFORMING
2364 * - \ref SCIP_STAGE_TRANSFORMED
2365 * - \ref SCIP_STAGE_INITPRESOLVE
2366 * - \ref SCIP_STAGE_PRESOLVING
2367 * - \ref SCIP_STAGE_EXITPRESOLVE
2368 * - \ref SCIP_STAGE_PRESOLVED
2369 * - \ref SCIP_STAGE_INITSOLVE
2370 * - \ref SCIP_STAGE_SOLVING
2371 * - \ref SCIP_STAGE_SOLVED
2372 * - \ref SCIP_STAGE_EXITSOLVE
2373 * - \ref SCIP_STAGE_FREETRANS
2374 */
2376 SCIP* scip, /**< SCIP data structure */
2377 FILE* file, /**< output file (or NULL for standard output) */
2378 const char* extension, /**< file format (or NULL for default CIP format)*/
2379 SCIP_Bool genericnames /**< using generic variable and constraint names? */
2380 )
2381{
2382 SCIP_RETCODE retcode;
2383
2384 SCIP_CALL( SCIPcheckStage(scip, "SCIPprintOrigProblem", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
2385
2386 assert(scip != NULL);
2387 assert( scip->origprob != NULL );
2388
2389 retcode = printProblem(scip, scip->origprob, file, extension, genericnames);
2390
2391 /* check for write errors */
2392 if( retcode == SCIP_WRITEERROR || retcode == SCIP_PLUGINNOTFOUND )
2393 return retcode;
2394 else
2395 {
2396 SCIP_CALL( retcode );
2397 }
2398
2399 return SCIP_OKAY;
2400}
2401
2402/** outputs transformed problem of the current node to file stream
2403 *
2404 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2405 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2406 *
2407 * @pre This method can be called if SCIP is in one of the following stages:
2408 * - \ref SCIP_STAGE_TRANSFORMED
2409 * - \ref SCIP_STAGE_INITPRESOLVE
2410 * - \ref SCIP_STAGE_PRESOLVING
2411 * - \ref SCIP_STAGE_EXITPRESOLVE
2412 * - \ref SCIP_STAGE_PRESOLVED
2413 * - \ref SCIP_STAGE_INITSOLVE
2414 * - \ref SCIP_STAGE_SOLVING
2415 * - \ref SCIP_STAGE_SOLVED
2416 * - \ref SCIP_STAGE_EXITSOLVE
2417 * - \ref SCIP_STAGE_FREETRANS
2418 */
2420 SCIP* scip, /**< SCIP data structure */
2421 FILE* file, /**< output file (or NULL for standard output) */
2422 const char* extension, /**< file format (or NULL for default CIP format)*/
2423 SCIP_Bool genericnames /**< using generic variable and constraint names? */
2424 )
2425{
2426 SCIP_RETCODE retcode;
2427
2428 SCIP_CALL( SCIPcheckStage(scip, "SCIPprintTransProblem", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
2429
2430 assert(scip != NULL);
2431 assert(scip->transprob != NULL );
2432
2433 retcode = printProblem(scip, scip->transprob, file, extension, genericnames);
2434
2435 /* check for write errors */
2436 if( retcode == SCIP_WRITEERROR || retcode == SCIP_PLUGINNOTFOUND )
2437 return retcode;
2438 else
2439 {
2440 SCIP_CALL( retcode );
2441 }
2442
2443 return SCIP_OKAY;
2444}
2445
2446/** outputs status statistics
2447 *
2448 * @note If limits have been changed between the solution and the call to this function, the status is recomputed and
2449 * thus may to correspond to the original status.
2450 *
2451 * @pre This method can be called if SCIP is in one of the following stages:
2452 * - \ref SCIP_STAGE_INIT
2453 * - \ref SCIP_STAGE_PROBLEM
2454 * - \ref SCIP_STAGE_TRANSFORMED
2455 * - \ref SCIP_STAGE_INITPRESOLVE
2456 * - \ref SCIP_STAGE_PRESOLVING
2457 * - \ref SCIP_STAGE_EXITPRESOLVE
2458 * - \ref SCIP_STAGE_PRESOLVED
2459 * - \ref SCIP_STAGE_SOLVING
2460 * - \ref SCIP_STAGE_SOLVED
2461 */
2463 SCIP* scip, /**< SCIP data structure */
2464 FILE* file /**< output file */
2465 )
2466{
2467 assert(scip != NULL);
2468 assert(scip->set != NULL);
2469
2470 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintStatusStatistics", TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2471
2472 SCIPmessageFPrintInfo(scip->messagehdlr, file, "SCIP Status : ");
2474 SCIPmessageFPrintInfo(scip->messagehdlr, file, "\n");
2475}
2476
2477/** outputs statistics for original problem
2478 *
2479 * @pre This method can be called if SCIP is in one of the following stages:
2480 * - \ref SCIP_STAGE_PROBLEM
2481 * - \ref SCIP_STAGE_TRANSFORMED
2482 * - \ref SCIP_STAGE_INITPRESOLVE
2483 * - \ref SCIP_STAGE_PRESOLVING
2484 * - \ref SCIP_STAGE_EXITPRESOLVE
2485 * - \ref SCIP_STAGE_PRESOLVED
2486 * - \ref SCIP_STAGE_SOLVING
2487 * - \ref SCIP_STAGE_SOLVED
2488 */
2490 SCIP* scip, /**< SCIP data structure */
2491 FILE* file /**< output file */
2492 )
2493{
2494 assert(scip != NULL);
2495 assert(scip->set != NULL);
2496
2497 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintOrigProblemStatistics", FALSE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2498
2499 SCIPmessageFPrintInfo(scip->messagehdlr, file, "Original Problem :\n");
2500 SCIPprobPrintStatistics(scip->origprob, scip->set, scip->messagehdlr, file);
2501}
2502
2503/** outputs statistics for transformed problem
2504 *
2505 * @pre This method can be called if SCIP is in one of the following stages:
2506 * - \ref SCIP_STAGE_PROBLEM
2507 * - \ref SCIP_STAGE_TRANSFORMED
2508 * - \ref SCIP_STAGE_INITPRESOLVE
2509 * - \ref SCIP_STAGE_PRESOLVING
2510 * - \ref SCIP_STAGE_EXITPRESOLVE
2511 * - \ref SCIP_STAGE_PRESOLVED
2512 * - \ref SCIP_STAGE_SOLVING
2513 * - \ref SCIP_STAGE_SOLVED
2514 */
2516 SCIP* scip, /**< SCIP data structure */
2517 FILE* file /**< output file */
2518 )
2519{
2520 assert(scip != NULL);
2521 assert(scip->set != NULL);
2522
2523 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintTransProblemStatistics", FALSE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2524
2525 SCIPmessageFPrintInfo(scip->messagehdlr, file, "Presolved Problem :\n");
2526 SCIPprobPrintStatistics(scip->transprob, scip->set, scip->messagehdlr, file);
2527 SCIPmessageFPrintInfo(scip->messagehdlr, file, " Nonzeros : %" SCIP_LONGINT_FORMAT " constraint, %" SCIP_LONGINT_FORMAT " clique table\n",
2528 scip->stat->nnz, SCIPcliquetableGetNEntries(scip->cliquetable));
2529}
2530
2531/** outputs presolver statistics
2532 *
2533 * @pre This method can be called if SCIP is in one of the following stages:
2534 * - \ref SCIP_STAGE_TRANSFORMED
2535 * - \ref SCIP_STAGE_INITPRESOLVE
2536 * - \ref SCIP_STAGE_PRESOLVING
2537 * - \ref SCIP_STAGE_EXITPRESOLVE
2538 * - \ref SCIP_STAGE_PRESOLVED
2539 * - \ref SCIP_STAGE_SOLVING
2540 * - \ref SCIP_STAGE_SOLVED
2541 */
2543 SCIP* scip, /**< SCIP data structure */
2544 FILE* file /**< output file */
2545 )
2546{
2547 int i;
2548
2549 assert(scip != NULL);
2550 assert(scip->set != NULL);
2551
2552 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintPresolverStatistics", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2553
2554 SCIPmessageFPrintInfo(scip->messagehdlr, file, "Presolvers : ExecTime SetupTime Calls FixedVars AggrVars ChgTypes ChgBounds AddHoles DelCons AddCons ChgSides ChgCoefs\n");
2555
2556 /* sort presolvers w.r.t. their name */
2558
2559 /* presolver statistics */
2560 for( i = 0; i < scip->set->npresols; ++i )
2561 {
2563 presol = scip->set->presols[i];
2564 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s:", SCIPpresolGetName(presol));
2565 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f %10.2f %6d %10d %10d %10d %10d %10d %10d %10d %10d %10d\n",
2578 }
2579
2580 /* sort propagators w.r.t. their name */
2582
2583 for( i = 0; i < scip->set->nprops; ++i )
2584 {
2585 SCIP_PROP* prop;
2586 prop = scip->set->props[i];
2587 if( SCIPpropDoesPresolve(prop) )
2588 {
2589 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s:", SCIPpropGetName(prop));
2590 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f %10.2f %6d %10d %10d %10d %10d %10d %10d %10d %10d %10d\n",
2597 SCIPpropGetNChgBds(prop),
2602 SCIPpropGetNChgCoefs(prop));
2603 }
2604 }
2605
2606 /* constraint handler presolving methods statistics */
2607 for( i = 0; i < scip->set->nconshdlrs; ++i )
2608 {
2609 SCIP_CONSHDLR* conshdlr;
2610 int maxnactiveconss;
2611
2612 conshdlr = scip->set->conshdlrs[i];
2613 maxnactiveconss = SCIPconshdlrGetMaxNActiveConss(conshdlr);
2614 if( SCIPconshdlrDoesPresolve(conshdlr)
2615 && (maxnactiveconss > 0 || !SCIPconshdlrNeedsCons(conshdlr)
2616 || SCIPconshdlrGetNFixedVars(conshdlr) > 0
2617 || SCIPconshdlrGetNAggrVars(conshdlr) > 0
2618 || SCIPconshdlrGetNChgVarTypes(conshdlr) > 0
2619 || SCIPconshdlrGetNChgBds(conshdlr) > 0
2620 || SCIPconshdlrGetNAddHoles(conshdlr) > 0
2621 || SCIPconshdlrGetNDelConss(conshdlr) > 0
2622 || SCIPconshdlrGetNAddConss(conshdlr) > 0
2623 || SCIPconshdlrGetNChgSides(conshdlr) > 0
2624 || SCIPconshdlrGetNChgCoefs(conshdlr) > 0
2625 || SCIPconshdlrGetNUpgdConss(conshdlr) > 0) )
2626 {
2627 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s:", SCIPconshdlrGetName(conshdlr));
2628 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f %10.2f %6d %10d %10d %10d %10d %10d %10d %10d %10d %10d\n",
2629 SCIPconshdlrGetPresolTime(conshdlr),
2630 SCIPconshdlrGetSetupTime(conshdlr),
2632 SCIPconshdlrGetNFixedVars(conshdlr),
2633 SCIPconshdlrGetNAggrVars(conshdlr),
2635 SCIPconshdlrGetNChgBds(conshdlr),
2636 SCIPconshdlrGetNAddHoles(conshdlr),
2637 SCIPconshdlrGetNDelConss(conshdlr),
2638 SCIPconshdlrGetNAddConss(conshdlr),
2639 SCIPconshdlrGetNChgSides(conshdlr),
2640 SCIPconshdlrGetNChgCoefs(conshdlr));
2641 }
2642 }
2643
2644 /* root node bound changes */
2645 SCIPmessageFPrintInfo(scip->messagehdlr, file, " root node : - - - %10d - - %10d - - - - -\n",
2646 scip->stat->nrootintfixings, scip->stat->nrootboundchgs);
2647}
2648
2649/** outputs constraint statistics
2650 *
2651 * @pre This method can be called if SCIP is in one of the following stages:
2652 * - \ref SCIP_STAGE_TRANSFORMED
2653 * - \ref SCIP_STAGE_INITPRESOLVE
2654 * - \ref SCIP_STAGE_PRESOLVING
2655 * - \ref SCIP_STAGE_EXITPRESOLVE
2656 * - \ref SCIP_STAGE_PRESOLVED
2657 * - \ref SCIP_STAGE_SOLVING
2658 * - \ref SCIP_STAGE_SOLVED
2659 */
2661 SCIP* scip, /**< SCIP data structure */
2662 FILE* file /**< output file */
2663 )
2664{
2665 int i;
2666
2667 assert(scip != NULL);
2668 assert(scip->set != NULL);
2669
2670 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintConstraintStatistics", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2671
2672 /* Add maximal number of constraints of the same type? So far this information is not added because of lack of space. */
2673 SCIPmessageFPrintInfo(scip->messagehdlr, file, "Constraints : Number MaxNumber #Separate #Propagate #EnfoLP #EnfoRelax #EnfoPS #Check #ResProp Cutoffs DomReds Cuts Applied Conss Children\n");
2674
2675 for( i = 0; i < scip->set->nconshdlrs; ++i )
2676 {
2677 SCIP_CONSHDLR* conshdlr;
2678 int startnactiveconss;
2679 int maxnactiveconss;
2680
2681 conshdlr = scip->set->conshdlrs[i];
2682 startnactiveconss = SCIPconshdlrGetStartNActiveConss(conshdlr);
2683 maxnactiveconss = SCIPconshdlrGetMaxNActiveConss(conshdlr);
2684 if( maxnactiveconss > 0 || !SCIPconshdlrNeedsCons(conshdlr) )
2685 {
2686 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s:", SCIPconshdlrGetName(conshdlr));
2688 startnactiveconss,
2689 maxnactiveconss > startnactiveconss ? '+' : ' ',
2690 maxnactiveconss,
2691 SCIPconshdlrGetNSepaCalls(conshdlr),
2692 SCIPconshdlrGetNPropCalls(conshdlr),
2698 SCIPconshdlrGetNCutoffs(conshdlr),
2700 SCIPconshdlrGetNCutsFound(conshdlr),
2703 SCIPconshdlrGetNChildren(conshdlr));
2704 }
2705 }
2706}
2707
2708/** outputs constraint timing statistics
2709 *
2710 * @pre This method can be called if SCIP is in one of the following stages:
2711 * - \ref SCIP_STAGE_TRANSFORMED
2712 * - \ref SCIP_STAGE_INITPRESOLVE
2713 * - \ref SCIP_STAGE_PRESOLVING
2714 * - \ref SCIP_STAGE_EXITPRESOLVE
2715 * - \ref SCIP_STAGE_PRESOLVED
2716 * - \ref SCIP_STAGE_SOLVING
2717 * - \ref SCIP_STAGE_SOLVED
2718 */
2720 SCIP* scip, /**< SCIP data structure */
2721 FILE* file /**< output file */
2722 )
2723{
2724 int i;
2725
2726 assert(scip != NULL);
2727 assert(scip->set != NULL);
2728
2729 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintConstraintTimingStatistics", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2730
2731 SCIPmessageFPrintInfo(scip->messagehdlr, file, "Constraint Timings : TotalTime SetupTime Separate Propagate EnfoLP EnfoPS EnfoRelax Check ResProp SB-Prop\n");
2732
2733 for( i = 0; i < scip->set->nconshdlrs; ++i )
2734 {
2735 SCIP_CONSHDLR* conshdlr;
2736 int maxnactiveconss;
2737
2738 conshdlr = scip->set->conshdlrs[i];
2739 maxnactiveconss = SCIPconshdlrGetMaxNActiveConss(conshdlr);
2740 if( maxnactiveconss > 0 || !SCIPconshdlrNeedsCons(conshdlr) )
2741 {
2742 SCIP_Real totaltime;
2743
2744 totaltime = SCIPconshdlrGetSepaTime(conshdlr) + SCIPconshdlrGetPropTime(conshdlr)
2746 + SCIPconshdlrGetEnfoLPTime(conshdlr)
2747 + SCIPconshdlrGetEnfoPSTime(conshdlr)
2749 + SCIPconshdlrGetCheckTime(conshdlr)
2750 + SCIPconshdlrGetRespropTime(conshdlr)
2751 + SCIPconshdlrGetSetupTime(conshdlr);
2752
2753 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s:", SCIPconshdlrGetName(conshdlr));
2754 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f %10.2f %10.2f %10.2f %10.2f %10.2f %10.2f %10.2f %10.2f %10.2f\n",
2755 totaltime,
2756 SCIPconshdlrGetSetupTime(conshdlr),
2757 SCIPconshdlrGetSepaTime(conshdlr),
2758 SCIPconshdlrGetPropTime(conshdlr),
2759 SCIPconshdlrGetEnfoLPTime(conshdlr),
2760 SCIPconshdlrGetEnfoPSTime(conshdlr),
2762 SCIPconshdlrGetCheckTime(conshdlr),
2765 }
2766 }
2767}
2768
2769/** outputs propagator statistics
2770 *
2771 * @pre This method can be called if SCIP is in one of the following stages:
2772 * - \ref SCIP_STAGE_TRANSFORMED
2773 * - \ref SCIP_STAGE_INITPRESOLVE
2774 * - \ref SCIP_STAGE_PRESOLVING
2775 * - \ref SCIP_STAGE_EXITPRESOLVE
2776 * - \ref SCIP_STAGE_PRESOLVED
2777 * - \ref SCIP_STAGE_SOLVING
2778 * - \ref SCIP_STAGE_SOLVED
2779 */
2781 SCIP* scip, /**< SCIP data structure */
2782 FILE* file /**< output file */
2783 )
2784{
2785 int i;
2786
2787 assert(scip != NULL);
2788 assert(scip->set != NULL);
2789
2790 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintPropagatorStatistics", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2791
2792 SCIPmessageFPrintInfo(scip->messagehdlr, file, "Propagators : #Propagate #ResProp Cutoffs DomReds\n");
2793
2794 /* sort propagaters w.r.t. their name */
2796
2797 for( i = 0; i < scip->set->nprops; ++i )
2798 {
2799 SCIP_PROP* prop;
2800 prop = scip->set->props[i];
2801
2802 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s: %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT "\n",
2803 SCIPpropGetName(prop),
2804 SCIPpropGetNCalls(prop),
2806 SCIPpropGetNCutoffs(prop),
2808 }
2809
2810 SCIPmessageFPrintInfo(scip->messagehdlr, file, "Propagator Timings : TotalTime SetupTime Presolve Propagate ResProp SB-Prop\n");
2811
2812 for( i = 0; i < scip->set->nprops; ++i )
2813 {
2814 SCIP_PROP* prop;
2815 SCIP_Real totaltime;
2816
2817 prop = scip->set->props[i];
2818 totaltime = SCIPpropGetPresolTime(prop) + SCIPpropGetTime(prop) + SCIPpropGetRespropTime(prop)
2820
2821 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s:", SCIPpropGetName(prop));
2822 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f %10.2f %10.2f %10.2f %10.2f %10.2f\n",
2823 totaltime,
2826 SCIPpropGetTime(prop),
2829 }
2830}
2831
2832/** outputs conflict statistics
2833 *
2834 * @pre This method can be called if SCIP is in one of the following stages:
2835 * - \ref SCIP_STAGE_TRANSFORMED
2836 * - \ref SCIP_STAGE_INITPRESOLVE
2837 * - \ref SCIP_STAGE_PRESOLVING
2838 * - \ref SCIP_STAGE_EXITPRESOLVE
2839 * - \ref SCIP_STAGE_PRESOLVED
2840 * - \ref SCIP_STAGE_SOLVING
2841 * - \ref SCIP_STAGE_SOLVED
2842 */
2844 SCIP* scip, /**< SCIP data structure */
2845 FILE* file /**< output file */
2846 )
2847{
2848 char initstoresize[SCIP_MAXSTRLEN];
2849 char maxstoresize[SCIP_MAXSTRLEN];
2850
2851 assert(scip != NULL);
2852 assert(scip->set != NULL);
2853
2854 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintConflictStatistics", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2855
2856 if( scip->set->conf_maxstoresize == 0 )
2857 {
2858 (void)SCIPsnprintf(initstoresize, SCIP_MAXSTRLEN, "inf");
2859 (void)SCIPsnprintf(maxstoresize, SCIP_MAXSTRLEN, "inf");
2860 }
2861 else
2862 {
2863 int initsize = SCIPconflictstoreGetInitPoolSize(scip->conflictstore);
2864 int maxsize = SCIPconflictstoreGetMaxPoolSize(scip->conflictstore);
2865
2866 if( maxsize == -1 )
2867 {
2868 (void)SCIPsnprintf(initstoresize, SCIP_MAXSTRLEN, "--");
2869 (void)SCIPsnprintf(maxstoresize, SCIP_MAXSTRLEN, "--");
2870 }
2871 else
2872 {
2873 assert(initsize >= 0);
2874 assert(maxsize >= 0);
2875
2876 (void)SCIPsnprintf(initstoresize, SCIP_MAXSTRLEN, "%d", initsize);
2877 (void)SCIPsnprintf(maxstoresize, SCIP_MAXSTRLEN, "%d", maxsize);
2878 }
2879 }
2880 SCIPmessageFPrintInfo(scip->messagehdlr, file, "Conflict Analysis : Time Calls Success DomReds Conflicts Literals Reconvs ReconvLits Dualrays Nonzeros LP Iters (pool size: [%s,%s])\n", initstoresize, maxstoresize);
2881 SCIPmessageFPrintInfo(scip->messagehdlr, file, " propagation : %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " - %10" SCIP_LONGINT_FORMAT " %10.1f %10" SCIP_LONGINT_FORMAT " %10.1f - - -\n",
2882 SCIPconflictGetPropTime(scip->conflict),
2887 ? (SCIP_Real)SCIPconflictGetNPropConflictLiterals(scip->conflict)
2888 / (SCIP_Real)SCIPconflictGetNPropConflictConss(scip->conflict) : 0,
2893 SCIPmessageFPrintInfo(scip->messagehdlr, file, " infeasible LP : %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " - %10" SCIP_LONGINT_FORMAT " %10.1f %10" SCIP_LONGINT_FORMAT " %10.1f %10" SCIP_LONGINT_FORMAT " %10.1f %10" SCIP_LONGINT_FORMAT "\n",
2900 / (SCIP_Real)SCIPconflictGetNInfeasibleLPConflictConss(scip->conflict) : 0,
2910 SCIPmessageFPrintInfo(scip->messagehdlr, file, " bound exceed. LP : %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " - %10" SCIP_LONGINT_FORMAT " %10.1f %10" SCIP_LONGINT_FORMAT " %10.1f %10" SCIP_LONGINT_FORMAT " %10.1f %10" SCIP_LONGINT_FORMAT "\n",
2917 / (SCIP_Real)SCIPconflictGetNBoundexceedingLPConflictConss(scip->conflict) : 0,
2927 SCIPmessageFPrintInfo(scip->messagehdlr, file, " strong branching : %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " - %10" SCIP_LONGINT_FORMAT " %10.1f %10" SCIP_LONGINT_FORMAT " %10.1f - - %10" SCIP_LONGINT_FORMAT "\n",
2934 / (SCIP_Real)SCIPconflictGetNStrongbranchConflictConss(scip->conflict) : 0,
2940 SCIPmessageFPrintInfo(scip->messagehdlr, file, " pseudo solution : %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " - %10" SCIP_LONGINT_FORMAT " %10.1f %10" SCIP_LONGINT_FORMAT " %10.1f - - -\n",
2946 ? (SCIP_Real)SCIPconflictGetNPseudoConflictLiterals(scip->conflict)
2947 / (SCIP_Real)SCIPconflictGetNPseudoConflictConss(scip->conflict) : 0,
2952 SCIPmessageFPrintInfo(scip->messagehdlr, file, " applied globally : %10.2f - - %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.1f - - %10" SCIP_LONGINT_FORMAT " - -\n",
2957 ? (SCIP_Real)SCIPconflictGetNAppliedGlobalLiterals(scip->conflict)
2958 / (SCIP_Real)SCIPconflictGetNAppliedGlobalConss(scip->conflict) : 0,
2960 SCIPmessageFPrintInfo(scip->messagehdlr, file, " applied locally : - - - %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.1f - - %10" SCIP_LONGINT_FORMAT " - -\n",
2964 ? (SCIP_Real)SCIPconflictGetNAppliedLocalLiterals(scip->conflict)
2965 / (SCIP_Real)SCIPconflictGetNAppliedLocalConss(scip->conflict) : 0,
2967}
2968
2969/** outputs separator statistics
2970 *
2971 * Columns:
2972 * - RootCalls: The number of calls that happened at the root.
2973 * - FoundCuts: The total number of cuts generated by the separators.
2974 * Note: Cutpool-FoundCuts \f$= \sum_{i=1}^nsepas ( Foundcuts_i - DirectAdd_i )\f$.
2975 * - ViaPoolAdd: The total number of cuts added to the sepastore from the cutpool.
2976 * - DirectAdd: The total number of cuts added directly to the sepastore from the separator.
2977 * - Applied: The sum of all cuts from the separator that were applied to the LP.
2978 * - ViaPoolApp: The number of cuts that entered the sepastore from the cutpool that were applied to the LP.
2979 * - DirectApp: The number of cuts that entered the sepastore directly and were applied to the LP.
2980 *
2981 * The number of cuts ViaPoolAdd + Directly should be equal to the number of cuts Filtered + Forced + Selected in the
2982 * cutselector statistics.
2983 *
2984 * @note The following edge case may lead to over or undercounting of statistics: When SCIPapplyCutsProbing() is
2985 * called, cuts are counted for the cut selection statistics, but not for the separator statistics. This
2986 * happens, e.g., in the default plugin prop_obbt.c.
2987 *
2988 * @pre This method can be called if SCIP is in one of the following stages:
2989 * - \ref SCIP_STAGE_SOLVING
2990 * - \ref SCIP_STAGE_SOLVED
2991 */
2993 SCIP* scip, /**< SCIP data structure */
2994 FILE* file /**< output file */
2995 )
2996{
2997 int i;
2998
2999 assert(scip != NULL);
3000 assert(scip->set != NULL);
3001
3002 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintSeparatorStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3003
3004 SCIPmessageFPrintInfo(scip->messagehdlr, file, "Separators : ExecTime SetupTime Calls RootCalls Cutoffs DomReds FoundCuts ViaPoolAdd DirectAdd Applied ViaPoolApp DirectApp Conss\n");
3005 SCIPmessageFPrintInfo(scip->messagehdlr, file, " cut pool : %10.2f - %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " - - %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " - - - - - (maximal pool size: %10" SCIP_LONGINT_FORMAT")\n",
3006 SCIPcutpoolGetTime(scip->cutpool),
3007 SCIPcutpoolGetNCalls(scip->cutpool),
3011 SCIPcutpoolGetMaxNCuts(scip->cutpool));
3012
3013 /* sort separators w.r.t. their name */
3015
3016 for( i = 0; i < scip->set->nsepas; ++i )
3017 {
3018 SCIP_SEPA* sepa;
3019
3020 sepa = scip->set->sepas[i];
3021
3022 /* only output data for separators without parent separator */
3023 if( SCIPsepaGetParentsepa(sepa) == NULL )
3024 {
3025 /* output data */
3027 SCIPsepaGetName(sepa),
3028 SCIPsepaGetTime(sepa),
3030 SCIPsepaGetNCalls(sepa),
3032 SCIPsepaGetNCutoffs(sepa),
3041
3042 /* for parent separators search for dependent separators */
3043 if( SCIPsepaIsParentsepa(sepa) )
3044 {
3045 SCIP_SEPA* parentsepa;
3046 int k;
3047
3048 for( k = 0; k < scip->set->nsepas; ++k )
3049 {
3050 if( k == i )
3051 continue;
3052
3053 parentsepa = SCIPsepaGetParentsepa(scip->set->sepas[k]);
3054 if( parentsepa != sepa )
3055 continue;
3056
3057 SCIPmessageFPrintInfo(scip->messagehdlr, file, " > %-15.17s: %10s %10s %10s %10s %10s %10s %10s %10" SCIP_LONGINT_FORMAT" %10" SCIP_LONGINT_FORMAT" %10" SCIP_LONGINT_FORMAT" %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10s\n",
3058 SCIPsepaGetName(scip->set->sepas[k]), "-", "-", "-", "-", "-", "-", "-",
3059 SCIPsepaGetNCutsAddedViaPool(scip->set->sepas[k]),
3060 SCIPsepaGetNCutsAddedDirect(scip->set->sepas[k]),
3061 SCIPsepaGetNCutsApplied(scip->set->sepas[k]),
3063 SCIPsepaGetNCutsAppliedDirect(scip->set->sepas[k]), "-");
3064 }
3065 }
3066 }
3067 }
3068}
3069
3070/** outputs cutselector statistics
3071 *
3072 * Filtered = ViaPoolAdd(Separators) + DirectAdd(Separators) - Selected - Cuts(Constraints)
3073 * Selected = Applied(Separators) + Applied(Constraints)
3074 *
3075 * @pre This method can be called if SCIP is in one of the following stages:
3076 * - \ref SCIP_STAGE_SOLVING
3077 * - \ref SCIP_STAGE_SOLVED
3078 */
3080 SCIP* scip, /**< SCIP data structure */
3081 FILE* file /**< output file */
3082 )
3083{
3084 int i;
3085
3086 assert(scip != NULL);
3087 assert(scip->set != NULL);
3088
3089 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintCutselectorStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3090
3091 SCIPmessageFPrintInfo(scip->messagehdlr, file, "Cutselectors : ExecTime SetupTime Calls RootCalls Selected Forced Filtered RootSelec RootForc RootFilt \n");
3092
3093 /* sort cutsels w.r.t. their priority */
3095
3096 for( i = 0; i < scip->set->ncutsels; ++i )
3097 {
3098 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s: %10.2f %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT "\n",
3099 SCIPcutselGetName(scip->set->cutsels[i]),
3100 SCIPcutselGetTime(scip->set->cutsels[i]),
3101 SCIPcutselGetSetupTime(scip->set->cutsels[i]),
3102 SCIPcutselGetNCalls(scip->set->cutsels[i]),
3103 SCIPcutselGetNRootCalls(scip->set->cutsels[i]),
3104 SCIPcutselGetNRootCuts(scip->set->cutsels[i]) + SCIPcutselGetNLocalCuts(scip->set->cutsels[i]),
3105 SCIPcutselGetNRootForcedCuts(scip->set->cutsels[i]) + SCIPcutselGetNLocalForcedCuts(scip->set->cutsels[i]),
3107 SCIPcutselGetNRootCuts(scip->set->cutsels[i]),
3108 SCIPcutselGetNRootForcedCuts(scip->set->cutsels[i]),
3109 SCIPcutselGetNRootCutsFiltered(scip->set->cutsels[i])
3110 );
3111 }
3112}
3113
3114/** outputs pricer statistics
3115 *
3116 * @pre This method can be called if SCIP is in one of the following stages:
3117 * - \ref SCIP_STAGE_SOLVING
3118 * - \ref SCIP_STAGE_SOLVED
3119 */
3121 SCIP* scip, /**< SCIP data structure */
3122 FILE* file /**< output file */
3123 )
3124{
3125 int i;
3126
3127 assert(scip != NULL);
3128 assert(scip->set != NULL);
3129
3130 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintPricerStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3131
3132 SCIPmessageFPrintInfo(scip->messagehdlr, file, "Pricers : ExecTime SetupTime Calls Vars\n");
3133 SCIPmessageFPrintInfo(scip->messagehdlr, file, " problem variables: %10.2f - %10d %10d\n",
3137
3138 /* sort pricers w.r.t. their name */
3140
3141 for( i = 0; i < scip->set->nactivepricers; ++i )
3142 {
3143 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s: %10.2f %10.2f %10d %10d\n",
3144 SCIPpricerGetName(scip->set->pricers[i]),
3145 SCIPpricerGetTime(scip->set->pricers[i]),
3146 SCIPpricerGetSetupTime(scip->set->pricers[i]),
3147 SCIPpricerGetNCalls(scip->set->pricers[i]),
3148 SCIPpricerGetNVarsFound(scip->set->pricers[i]));
3149 }
3150}
3151
3152/** outputs branching rule statistics
3153 *
3154 * @pre This method can be called if SCIP is in one of the following stages:
3155 * - \ref SCIP_STAGE_SOLVING
3156 * - \ref SCIP_STAGE_SOLVED
3157 */
3159 SCIP* scip, /**< SCIP data structure */
3160 FILE* file /**< output file */
3161 )
3162{
3163 int i;
3164
3165 assert(scip != NULL);
3166 assert(scip->set != NULL);
3167
3168 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintBranchruleStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3169
3170 SCIPmessageFPrintInfo(scip->messagehdlr, file, "Branching Rules : ExecTime SetupTime BranchLP BranchExt BranchPS Cutoffs DomReds Cuts Conss Children\n");
3171
3172 /* sort branching rules w.r.t. their name */
3174
3175 for( i = 0; i < scip->set->nbranchrules; ++i )
3176 {
3177 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s: %10.2f %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT "\n",
3178 SCIPbranchruleGetName(scip->set->branchrules[i]),
3179 SCIPbranchruleGetTime(scip->set->branchrules[i]),
3180 SCIPbranchruleGetSetupTime(scip->set->branchrules[i]),
3181 SCIPbranchruleGetNLPCalls(scip->set->branchrules[i]),
3182 SCIPbranchruleGetNExternCalls(scip->set->branchrules[i]),
3183 SCIPbranchruleGetNPseudoCalls(scip->set->branchrules[i]),
3184 SCIPbranchruleGetNCutoffs(scip->set->branchrules[i]),
3185 SCIPbranchruleGetNDomredsFound(scip->set->branchrules[i]),
3186 SCIPbranchruleGetNCutsFound(scip->set->branchrules[i]),
3187 SCIPbranchruleGetNConssFound(scip->set->branchrules[i]),
3188 SCIPbranchruleGetNChildren(scip->set->branchrules[i]));
3189 }
3190}
3191
3192/** outputs heuristics statistics
3193 *
3194 * @pre This method can be called if SCIP is in one of the following stages:
3195 * - \ref SCIP_STAGE_PRESOLVING
3196 * - \ref SCIP_STAGE_EXITPRESOLVE
3197 * - \ref SCIP_STAGE_PRESOLVED
3198 * - \ref SCIP_STAGE_SOLVING
3199 * - \ref SCIP_STAGE_SOLVED
3200 */
3202 SCIP* scip, /**< SCIP data structure */
3203 FILE* file /**< output file */
3204 )
3205{
3206 int ndivesets = 0;
3207 int i;
3208
3209 assert(scip != NULL);
3210 assert(scip->set != NULL);
3211 assert(scip->tree != NULL);
3212
3213 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintHeuristicStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3214
3215 SCIPmessageFPrintInfo(scip->messagehdlr, file, "Primal Heuristics : ExecTime SetupTime Calls Found Best\n");
3216 SCIPmessageFPrintInfo(scip->messagehdlr, file, " LP solutions : %10.2f - - %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT "\n",
3217 SCIPclockGetTime(scip->stat->lpsoltime),
3218 scip->stat->nlpsolsfound, scip->stat->nlpbestsolsfound);
3219 SCIPmessageFPrintInfo(scip->messagehdlr, file, " relax solutions : %10.2f - - %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT "\n",
3220 SCIPclockGetTime(scip->stat->relaxsoltime),
3221 scip->stat->nrelaxsolsfound, scip->stat->nrelaxbestsolsfound);
3222 SCIPmessageFPrintInfo(scip->messagehdlr, file, " pseudo solutions : %10.2f - - %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT "\n",
3223 SCIPclockGetTime(scip->stat->pseudosoltime),
3224 scip->stat->npssolsfound, scip->stat->npsbestsolsfound);
3225 SCIPmessageFPrintInfo(scip->messagehdlr, file, " strong branching : %10.2f - - %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT "\n",
3226 SCIPclockGetTime(scip->stat->sbsoltime),
3227 scip->stat->nsbsolsfound, scip->stat->nsbbestsolsfound);
3228
3229 /* sort heuristics w.r.t. their names */
3231
3232 for( i = 0; i < scip->set->nheurs; ++i )
3233 {
3234 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s: %10.2f %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT "\n",
3235 SCIPheurGetName(scip->set->heurs[i]),
3236 SCIPheurGetTime(scip->set->heurs[i]),
3237 SCIPheurGetSetupTime(scip->set->heurs[i]),
3238 SCIPheurGetNCalls(scip->set->heurs[i]),
3239 SCIPheurGetNSolsFound(scip->set->heurs[i]),
3240 SCIPheurGetNBestSolsFound(scip->set->heurs[i]));
3241
3242 /* count heuristics that use diving; needed to determine output later */
3243 ndivesets += SCIPheurGetNDivesets(scip->set->heurs[i]);
3244 }
3245
3246 SCIPmessageFPrintInfo(scip->messagehdlr, file, " other solutions : - - - %10" SCIP_LONGINT_FORMAT " -\n",
3247 scip->stat->nexternalsolsfound);
3248
3249 if ( ndivesets > 0 && scip->set->misc_showdivingstats )
3250 {
3251 int c;
3253
3254 /* print statistics for all three contexts individually */
3255 for( c = 0; c < 3; ++c )
3256 {
3258
3260 {
3261 SCIPmessageFPrintInfo(scip->messagehdlr, file,
3262 "Diving %-12s: Calls Nodes LP Iters Backtracks Conflicts MinDepth MaxDepth AvgDepth RoundSols NLeafSols MinSolDpt MaxSolDpt AvgSolDpt\n", "(single)");
3263 }
3264 else
3265 {
3266 SCIPmessageFPrintInfo(scip->messagehdlr, file,
3267 "Diving %-12s: Calls Nodes LP Iters Backtracks Conflicts MinDepth MaxDepth AvgDepth RoundSols NLeafSols MinSolDpt MaxSolDpt AvgSolDpt\n",
3268 divecontext == SCIP_DIVECONTEXT_ADAPTIVE ? "(adaptive)" : "(scheduler)");
3269 }
3270
3271 for( i = 0; i < scip->set->nheurs; ++i )
3272 {
3273 int s;
3274 for( s = 0; s < SCIPheurGetNDivesets(scip->set->heurs[i]); ++s )
3275 {
3276 SCIP_DIVESET* diveset = SCIPheurGetDivesets(scip->set->heurs[i])[s];
3277
3278 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s: %10d",
3282 {
3283 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10d %10d %10.1f %10" SCIP_LONGINT_FORMAT,
3292
3294 {
3295 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10d %10d %10d %10.1f\n",
3300 }
3301 else
3302 SCIPmessageFPrintInfo(scip->messagehdlr, file, " - - - -\n");
3303 }
3304 else
3305 SCIPmessageFPrintInfo(scip->messagehdlr, file, " - - - - - - - - - - - -\n");
3306 }
3307 }
3308 }
3309 }
3310}
3311
3312/** outputs compression statistics
3313 *
3314 * @pre This method can be called if SCIP is in one of the following stages:
3315 * - \ref SCIP_STAGE_PRESOLVING
3316 * - \ref SCIP_STAGE_EXITPRESOLVE
3317 * - \ref SCIP_STAGE_PRESOLVED
3318 * - \ref SCIP_STAGE_SOLVING
3319 * - \ref SCIP_STAGE_SOLVED
3320 */
3322 SCIP* scip, /**< SCIP data structure */
3323 FILE* file /**< output file */
3324 )
3325{
3326 int i;
3327
3328 assert(scip != NULL);
3329
3330 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintCompressionStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3331
3332 /* only print compression statistics if tree reoptimization is enabled */
3333 if( !scip->set->reopt_enable )
3334 return;
3335
3336 SCIPmessageFPrintInfo(scip->messagehdlr, file, "Tree Compressions : ExecTime SetupTime Calls Found\n");
3337
3338 /* sort compressions w.r.t. their names */
3340
3341 for( i = 0; i < scip->set->ncomprs; ++i )
3342 {
3343 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s: %10.2f %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT "\n",
3344 SCIPcomprGetName(scip->set->comprs[i]),
3345 SCIPcomprGetTime(scip->set->comprs[i]),
3346 SCIPcomprGetSetupTime(scip->set->comprs[i]),
3347 SCIPcomprGetNCalls(scip->set->comprs[i]),
3348 SCIPcomprGetNFound(scip->set->comprs[i]));
3349 }
3350}
3351
3352/** outputs LP statistics
3353 *
3354 * @pre This method can be called if SCIP is in one of the following stages:
3355 * - \ref SCIP_STAGE_SOLVING
3356 * - \ref SCIP_STAGE_SOLVED
3357 */
3359 SCIP* scip, /**< SCIP data structure */
3360 FILE* file /**< output file */
3361 )
3362{
3363 assert(scip != NULL);
3364 assert(scip->stat != NULL);
3365 assert(scip->lp != NULL);
3366
3368
3369 SCIPmessageFPrintInfo(scip->messagehdlr, file, "LP : Time Calls Iterations Iter/call Iter/sec Time-0-It Calls-0-It ItLimit\n");
3370
3371 SCIPmessageFPrintInfo(scip->messagehdlr, file, " primal LP : %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.2f",
3372 SCIPclockGetTime(scip->stat->primallptime),
3373 scip->stat->nprimallps + scip->stat->nprimalzeroitlps,
3374 scip->stat->nprimallpiterations,
3375 scip->stat->nprimallps > 0 ? (SCIP_Real)scip->stat->nprimallpiterations/(SCIP_Real)scip->stat->nprimallps : 0.0);
3376 if( SCIPclockGetTime(scip->stat->primallptime) >= 0.01 )
3377 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f", (SCIP_Real)scip->stat->nprimallpiterations/SCIPclockGetTime(scip->stat->primallptime));
3378 else
3379 SCIPmessageFPrintInfo(scip->messagehdlr, file, " -");
3380 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f %10" SCIP_LONGINT_FORMAT "\n",
3381 scip->stat->primalzeroittime,
3382 scip->stat->nprimalzeroitlps);
3383
3384 SCIPmessageFPrintInfo(scip->messagehdlr, file, " dual LP : %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.2f",
3385 SCIPclockGetTime(scip->stat->duallptime),
3386 scip->stat->nduallps + scip->stat->ndualzeroitlps,
3387 scip->stat->nduallpiterations,
3388 scip->stat->nduallps > 0 ? (SCIP_Real)scip->stat->nduallpiterations/(SCIP_Real)scip->stat->nduallps : 0.0);
3389 if( SCIPclockGetTime(scip->stat->duallptime) >= 0.01 )
3390 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f", (SCIP_Real)scip->stat->nduallpiterations/SCIPclockGetTime(scip->stat->duallptime));
3391 else
3392 SCIPmessageFPrintInfo(scip->messagehdlr, file, " -");
3393 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f %10" SCIP_LONGINT_FORMAT "\n",
3394 scip->stat->dualzeroittime,
3395 scip->stat->ndualzeroitlps);
3396
3397 SCIPmessageFPrintInfo(scip->messagehdlr, file, " lex dual LP : %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.2f",
3398 SCIPclockGetTime(scip->stat->lexduallptime),
3399 scip->stat->nlexduallps,
3400 scip->stat->nlexduallpiterations,
3401 scip->stat->nlexduallps > 0 ? (SCIP_Real)scip->stat->nlexduallpiterations/(SCIP_Real)scip->stat->nlexduallps : 0.0);
3402 if( SCIPclockGetTime(scip->stat->lexduallptime) >= 0.01 )
3403 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f\n", (SCIP_Real)scip->stat->nlexduallpiterations/SCIPclockGetTime(scip->stat->lexduallptime));
3404 else
3405 SCIPmessageFPrintInfo(scip->messagehdlr, file, " -\n");
3406
3407 SCIPmessageFPrintInfo(scip->messagehdlr, file, " barrier LP : %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.2f",
3408 SCIPclockGetTime(scip->stat->barrierlptime),
3409 scip->stat->nbarrierlps,
3410 scip->stat->nbarrierlpiterations,
3411 scip->stat->nbarrierlps > 0 ? (SCIP_Real)scip->stat->nbarrierlpiterations/(SCIP_Real)scip->stat->nbarrierlps : 0.0);
3412 if( SCIPclockGetTime(scip->stat->barrierlptime) >= 0.01 )
3413 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f", (SCIP_Real)scip->stat->nbarrierlpiterations/SCIPclockGetTime(scip->stat->barrierlptime));
3414 else
3415 SCIPmessageFPrintInfo(scip->messagehdlr, file, " -");
3416 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f %10" SCIP_LONGINT_FORMAT "\n",
3417 scip->stat->barrierzeroittime,
3418 scip->stat->nbarrierzeroitlps);
3419
3420 SCIPmessageFPrintInfo(scip->messagehdlr, file, " resolve instable : %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.2f",
3421 SCIPclockGetTime(scip->stat->resolveinstablelptime),
3422 scip->stat->nresolveinstablelps,
3423 scip->stat->nresolveinstablelpiters,
3424 scip->stat->nresolveinstablelps > 0 ? (SCIP_Real)scip->stat->nresolveinstablelpiters/(SCIP_Real)scip->stat->nresolveinstablelps : 0.0);
3425 if( SCIPclockGetTime(scip->stat->resolveinstablelptime) >= 0.01 )
3426 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f\n", (SCIP_Real)scip->stat->nresolveinstablelpiters/SCIPclockGetTime(scip->stat->resolveinstablelptime));
3427 else
3428 SCIPmessageFPrintInfo(scip->messagehdlr, file, " -\n");
3429
3430 SCIPmessageFPrintInfo(scip->messagehdlr, file, " diving/probing LP: %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.2f",
3431 SCIPclockGetTime(scip->stat->divinglptime),
3432 scip->stat->ndivinglps,
3433 scip->stat->ndivinglpiterations,
3434 scip->stat->ndivinglps > 0 ? (SCIP_Real)scip->stat->ndivinglpiterations/(SCIP_Real)scip->stat->ndivinglps : 0.0);
3435 if( SCIPclockGetTime(scip->stat->divinglptime) >= 0.01 )
3436 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f\n", (SCIP_Real)scip->stat->ndivinglpiterations/SCIPclockGetTime(scip->stat->divinglptime));
3437 else
3438 SCIPmessageFPrintInfo(scip->messagehdlr, file, " -\n");
3439
3440 SCIPmessageFPrintInfo(scip->messagehdlr, file, " strong branching : %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.2f",
3441 SCIPclockGetTime(scip->stat->strongbranchtime),
3442 scip->stat->nstrongbranchs,
3443 scip->stat->nsblpiterations,
3444 scip->stat->nstrongbranchs > 0 ? (SCIP_Real)scip->stat->nsblpiterations/(SCIP_Real)scip->stat->nstrongbranchs : 0.0);
3445 if( SCIPclockGetTime(scip->stat->strongbranchtime) >= 0.01 )
3446 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f", (SCIP_Real)scip->stat->nsblpiterations/SCIPclockGetTime(scip->stat->strongbranchtime));
3447 else
3448 SCIPmessageFPrintInfo(scip->messagehdlr, file, " -");
3449 SCIPmessageFPrintInfo(scip->messagehdlr, file, " - - %10" SCIP_LONGINT_FORMAT "\n", scip->stat->nsbtimesiterlimhit);
3450
3451 SCIPmessageFPrintInfo(scip->messagehdlr, file, " (at root node) : - %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.2f -\n",
3452 scip->stat->nrootstrongbranchs,
3453 scip->stat->nrootsblpiterations,
3454 scip->stat->nrootstrongbranchs > 0
3455 ? (SCIP_Real)scip->stat->nrootsblpiterations/(SCIP_Real)scip->stat->nrootstrongbranchs : 0.0);
3456
3457 SCIPmessageFPrintInfo(scip->messagehdlr, file, " conflict analysis: %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.2f",
3458 SCIPclockGetTime(scip->stat->conflictlptime),
3459 scip->stat->nconflictlps,
3460 scip->stat->nconflictlpiterations,
3461 scip->stat->nconflictlps > 0 ? (SCIP_Real)scip->stat->nconflictlpiterations/(SCIP_Real)scip->stat->nconflictlps : 0.0);
3462 if( SCIPclockGetTime(scip->stat->conflictlptime) >= 0.01 )
3463 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f\n", (SCIP_Real)scip->stat->nconflictlpiterations/SCIPclockGetTime(scip->stat->conflictlptime));
3464 else
3465 SCIPmessageFPrintInfo(scip->messagehdlr, file, " -\n");
3466}
3467
3468/** outputs NLP statistics
3469 *
3470 * @pre This method can be called if SCIP is in one of the following stages:
3471 * - \ref SCIP_STAGE_SOLVING
3472 * - \ref SCIP_STAGE_SOLVED
3473 */
3475 SCIP* scip, /**< SCIP data structure */
3476 FILE* file /**< output file */
3477 )
3478{
3479 int nnlrowlinear;
3480 int nnlrowconvexineq;
3481 int nnlrownonconvexineq;
3482 int nnlrownonlineareq;
3483
3484 assert(scip != NULL);
3485 assert(scip->stat != NULL);
3486
3488
3489 if( scip->nlp == NULL )
3490 return;
3491
3492 SCIPmessageFPrintInfo(scip->messagehdlr, file, "NLP relaxation :\n");
3493
3494 SCIPmessageFPrintInfo(scip->messagehdlr, file, " solve time : %10.2f (%" SCIP_LONGINT_FORMAT " calls)\n",
3495 SCIPclockGetTime(scip->stat->nlpsoltime),
3496 scip->stat->nnlps);
3497
3498 SCIP_CALL_ABORT( SCIPgetNLPNlRowsStat(scip, &nnlrowlinear, &nnlrowconvexineq, &nnlrownonconvexineq, &nnlrownonlineareq) );
3499 SCIPmessageFPrintInfo(scip->messagehdlr, file, " convexity : %10s (%d linear rows, %d convex ineq., %d nonconvex ineq., %d nonlinear eq. or two-sided ineq.)\n",
3500 (nnlrownonconvexineq == 0 && nnlrownonlineareq == 0) ? "convex" : "nonconvex",
3501 nnlrowlinear, nnlrowconvexineq, nnlrownonconvexineq, nnlrownonlineareq);
3502}
3503
3504/** outputs relaxator statistics
3505 *
3506 * @pre This method can be called if SCIP is in one of the following stages:
3507 * - \ref SCIP_STAGE_SOLVING
3508 * - \ref SCIP_STAGE_SOLVED
3509 */
3511 SCIP* scip, /**< SCIP data structure */
3512 FILE* file /**< output file */
3513 )
3514{
3515 int i;
3516
3517 assert(scip != NULL);
3518 assert(scip->set != NULL);
3519
3520 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintRelaxatorStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3521
3522 if( scip->set->nrelaxs == 0 )
3523 return;
3524
3525 SCIPmessageFPrintInfo(scip->messagehdlr, file, "Relaxators : Time Calls Cutoffs ImprBounds ImprTime ReducedDom Separated AddedConss\n");
3526
3527 /* sort relaxators w.r.t. their name */
3529
3530 for( i = 0; i < scip->set->nrelaxs; ++i )
3531 {
3532 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s: %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT "\n",
3533 SCIPrelaxGetName(scip->set->relaxs[i]),
3534 SCIPrelaxGetTime(scip->set->relaxs[i]),
3535 SCIPrelaxGetNCalls(scip->set->relaxs[i]),
3536 SCIPrelaxGetNCutoffs(scip->set->relaxs[i]),
3537 SCIPrelaxGetNImprovedLowerbound(scip->set->relaxs[i]),
3539 SCIPrelaxGetNReducedDomains(scip->set->relaxs[i]),
3540 SCIPrelaxGetNSeparatedCuts(scip->set->relaxs[i]),
3541 SCIPrelaxGetNAddedConss(scip->set->relaxs[i])
3542 );
3543 }
3544}
3545
3546/** outputs tree statistics
3547 *
3548 * @pre This method can be called if SCIP is in one of the following stages:
3549 * - \ref SCIP_STAGE_SOLVING
3550 * - \ref SCIP_STAGE_SOLVED
3551 */
3553 SCIP* scip, /**< SCIP data structure */
3554 FILE* file /**< output file */
3555 )
3556{
3557 assert(scip != NULL);
3558 assert(scip->stat != NULL);
3559 assert(scip->tree != NULL);
3560
3561 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintTreeStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3562
3563 SCIPmessageFPrintInfo(scip->messagehdlr, file, "B&B Tree :\n");
3564 SCIPmessageFPrintInfo(scip->messagehdlr, file, " number of runs : %10d\n", scip->stat->nruns);
3565 SCIPmessageFPrintInfo(scip->messagehdlr, file,
3566 " nodes : %10" SCIP_LONGINT_FORMAT " (%" SCIP_LONGINT_FORMAT " internal, %" SCIP_LONGINT_FORMAT " leaves)\n",
3567 scip->stat->nnodes, scip->stat->ninternalnodes, scip->stat->nnodes - scip->stat->ninternalnodes );
3568 SCIPmessageFPrintInfo(scip->messagehdlr, file, " feasible leaves : %10" SCIP_LONGINT_FORMAT "\n", scip->stat->nfeasleaves);
3569 SCIPmessageFPrintInfo(scip->messagehdlr, file, " infeas. leaves : %10" SCIP_LONGINT_FORMAT "\n", scip->stat->ninfeasleaves);
3570 SCIPmessageFPrintInfo(scip->messagehdlr, file, " objective leaves : %10" SCIP_LONGINT_FORMAT "\n", scip->stat->nobjleaves);
3571 SCIPmessageFPrintInfo(scip->messagehdlr, file,
3572 " nodes (total) : %10" SCIP_LONGINT_FORMAT " (%" SCIP_LONGINT_FORMAT " internal, %" SCIP_LONGINT_FORMAT " leaves)\n",
3573 scip->stat->ntotalnodes, scip->stat->ntotalinternalnodes, scip->stat->ntotalnodes - scip->stat->ntotalinternalnodes);
3574 SCIPmessageFPrintInfo(scip->messagehdlr, file, " nodes left : %10d\n", SCIPtreeGetNNodes(scip->tree));
3575 SCIPmessageFPrintInfo(scip->messagehdlr, file, " max depth : %10d\n", scip->stat->maxdepth);
3576 SCIPmessageFPrintInfo(scip->messagehdlr, file, " max depth (total): %10d\n", scip->stat->maxtotaldepth);
3577 SCIPmessageFPrintInfo(scip->messagehdlr, file, " backtracks : %10" SCIP_LONGINT_FORMAT " (%.1f%%)\n", scip->stat->nbacktracks,
3578 scip->stat->nnodes > 0 ? 100.0 * (SCIP_Real)scip->stat->nbacktracks / (SCIP_Real)scip->stat->nnodes : 0.0);
3579 SCIPmessageFPrintInfo(scip->messagehdlr, file, " early backtracks : %10" SCIP_LONGINT_FORMAT " (%.1f%%)\n", scip->stat->nearlybacktracks,
3580 scip->stat->nbacktracks > 0 ? 100.0 * (SCIP_Real)scip->stat->nearlybacktracks / (SCIP_Real)scip->stat->nbacktracks : 0.0);
3581 SCIPmessageFPrintInfo(scip->messagehdlr, file, " nodes exc. ref. : %10" SCIP_LONGINT_FORMAT " (%.1f%%)\n", scip->stat->nnodesaboverefbound,
3582 scip->stat->nnodes > 0 ? 100.0 * (SCIP_Real)scip->stat->nnodesaboverefbound / (SCIP_Real)scip->stat->nnodes : 0.0);
3583
3584 SCIPmessageFPrintInfo(scip->messagehdlr, file, " delayed cutoffs : %10" SCIP_LONGINT_FORMAT "\n", scip->stat->ndelayedcutoffs);
3585 SCIPmessageFPrintInfo(scip->messagehdlr, file, " repropagations : %10" SCIP_LONGINT_FORMAT " (%" SCIP_LONGINT_FORMAT " domain reductions, %" SCIP_LONGINT_FORMAT " cutoffs)\n",
3586 scip->stat->nreprops, scip->stat->nrepropboundchgs, scip->stat->nrepropcutoffs);
3587 SCIPmessageFPrintInfo(scip->messagehdlr, file, " avg switch length: %10.2f\n",
3588 scip->stat->nnodes > 0
3589 ? (SCIP_Real)(scip->stat->nactivatednodes + scip->stat->ndeactivatednodes) / (SCIP_Real)scip->stat->nnodes : 0.0);
3590 SCIPmessageFPrintInfo(scip->messagehdlr, file, " switching time : %10.2f\n", SCIPclockGetTime(scip->stat->nodeactivationtime));
3591}
3592
3593/** outputs solution statistics
3594 *
3595 * @pre This method can be called if SCIP is in one of the following stages:
3596 * - \ref SCIP_STAGE_PRESOLVING
3597 * - \ref SCIP_STAGE_EXITPRESOLVE
3598 * - \ref SCIP_STAGE_PRESOLVED
3599 * - \ref SCIP_STAGE_SOLVING
3600 * - \ref SCIP_STAGE_SOLVED
3601 */
3603 SCIP* scip, /**< SCIP data structure */
3604 FILE* file /**< output file */
3605 )
3606{
3607 SCIP_Real primalbound;
3608 SCIP_Real dualbound;
3609 SCIP_Real gap;
3610 SCIP_Real firstprimalbound;
3611 SCIP_Bool objlimitreached;
3613
3614 assert(scip != NULL);
3615 assert(scip->stat != NULL);
3616 assert(scip->primal != NULL);
3617
3618 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintSolutionStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3619
3621 dualbound = SCIPgetDualbound(scip);
3622 gap = SCIPgetGap(scip);
3623
3624 /* We output that the objective limit has been reached if the problem has been solved, no solution respecting the
3625 * objective limit has been found (nlimsolsfound == 0) and the primal bound is finite. Note that it still might be
3626 * that the original problem is infeasible, even without the objective limit, i.e., we cannot be sure that we
3627 * actually reached the objective limit. */
3629 if( SCIPgetStage(scip) == SCIP_STAGE_SOLVED && scip->primal->nlimsolsfound == 0
3632
3633 if( scip->primal->nsolsfound != scip->primal->nlimsolsfound )
3634 (void) SCIPsnprintf(limsolstring, SCIP_MAXSTRLEN, ", %" SCIP_LONGINT_FORMAT " respecting the objective limit", scip->primal->nlimsolsfound);
3635 else
3636 limsolstring[0] = '\0';
3637
3638 SCIPmessageFPrintInfo(scip->messagehdlr, file, "Solution :\n");
3639 SCIPmessageFPrintInfo(scip->messagehdlr, file, " Solutions found : %10" SCIP_LONGINT_FORMAT " (%" SCIP_LONGINT_FORMAT " improvements%s)\n",
3640 scip->primal->nsolsfound, scip->primal->nbestsolsfound, limsolstring);
3641
3643 {
3644 if( scip->set->stage == SCIP_STAGE_SOLVED )
3645 {
3646 if( scip->primal->nlimsolsfound == 0 )
3647 {
3649 {
3651 SCIPmessageFPrintInfo(scip->messagehdlr, file, " Primal Bound : infeasible or unbounded\n");
3652 }
3653 else
3654 {
3656 if( objlimitreached )
3657 SCIPmessageFPrintInfo(scip->messagehdlr, file, " Primal Bound : infeasible (objective limit reached)\n");
3658 else
3659 SCIPmessageFPrintInfo(scip->messagehdlr, file, " Primal Bound : infeasible\n");
3660 }
3661 }
3662 else
3663 {
3666 SCIPmessageFPrintInfo(scip->messagehdlr, file, " Primal Bound : unbounded\n");
3667 }
3668 }
3669 else
3670 SCIPmessageFPrintInfo(scip->messagehdlr, file, " Primal Bound : -\n");
3671 }
3672 else
3673 {
3674 if( scip->primal->nlimsolsfound == 0 )
3675 {
3676 SCIPmessageFPrintInfo(scip->messagehdlr, file, " Primal Bound : %+21.14e (objective limit)\n", primalbound);
3677
3678 /* display (best) primal bound */
3679 if( scip->primal->nsolsfound > 0 )
3680 {
3681 SCIP_Real bestsol;
3682 bestsol = SCIPsolGetObj(scip->primal->sols[0], scip->set, scip->transprob, scip->origprob);
3683 bestsol = SCIPretransformObj(scip, bestsol);
3684
3685 SCIPmessageFPrintInfo(scip->messagehdlr, file, " Best Solution : %+21.14e\n", bestsol);
3686 }
3687 }
3688 else
3689 {
3690 /* display first primal bound line */
3691 firstprimalbound = scip->stat->firstprimalbound;
3692 SCIPmessageFPrintInfo(scip->messagehdlr, file, " First Solution : %+21.14e", firstprimalbound);
3693
3694 SCIPmessageFPrintInfo(scip->messagehdlr, file, " (in run %d, after %" SCIP_LONGINT_FORMAT " nodes, %.2f seconds, depth %d, found by <%s>)\n",
3695 scip->stat->nrunsbeforefirst,
3696 scip->stat->nnodesbeforefirst,
3697 scip->stat->firstprimaltime,
3698 scip->stat->firstprimaldepth,
3699 ( scip->stat->firstprimalheur != NULL )
3700 ? ( SCIPheurGetName(scip->stat->firstprimalheur) )
3701 : (( scip->stat->nrunsbeforefirst == 0 ) ? "initial" : "relaxation"));
3702
3703 if( SCIPisInfinity(scip, scip->stat->firstsolgap) )
3704 SCIPmessageFPrintInfo(scip->messagehdlr, file, " Gap First Sol. : infinite\n");
3705 else
3706 SCIPmessageFPrintInfo(scip->messagehdlr, file, " Gap First Sol. : %10.2f %%\n", 100.0 * scip->stat->firstsolgap);
3707
3708 if( SCIPisInfinity(scip, scip->stat->lastsolgap) )
3709 SCIPmessageFPrintInfo(scip->messagehdlr, file, " Gap Last Sol. : infinite\n");
3710 else
3711 SCIPmessageFPrintInfo(scip->messagehdlr, file, " Gap Last Sol. : %10.2f %%\n", 100.0 * scip->stat->lastsolgap);
3712
3713 SCIPmessageFPrintInfo(scip->messagehdlr, file, " Primal Bound : %+21.14e", primalbound);
3714
3715 SCIPmessageFPrintInfo(scip->messagehdlr, file, " (in run %d, after %" SCIP_LONGINT_FORMAT " nodes, %.2f seconds, depth %d, found by <%s>)\n",
3716 SCIPsolGetRunnum(scip->primal->sols[0]),
3717 SCIPsolGetNodenum(scip->primal->sols[0]),
3718 SCIPsolGetTime(scip->primal->sols[0]),
3719 SCIPsolGetDepth(scip->primal->sols[0]),
3720 SCIPsolGetHeur(scip->primal->sols[0]) != NULL
3721 ? SCIPheurGetName(SCIPsolGetHeur(scip->primal->sols[0]))
3722 : (SCIPsolGetRunnum(scip->primal->sols[0]) == 0 ? "initial" : "relaxation"));
3723 }
3724 }
3725
3726 if( SCIPsetIsInfinity(scip->set, REALABS(dualbound)) )
3727 SCIPmessageFPrintInfo(scip->messagehdlr, file, " Dual Bound : -\n");
3728 else
3729 SCIPmessageFPrintInfo(scip->messagehdlr, file, " Dual Bound : %+21.14e\n", dualbound);
3730
3731 if( SCIPsetIsInfinity(scip->set, gap) )
3732 SCIPmessageFPrintInfo(scip->messagehdlr, file, " Gap : infinite\n");
3733 else
3734 SCIPmessageFPrintInfo(scip->messagehdlr, file, " Gap : %10.2f %%\n", 100.0 * gap);
3735
3736 if( scip->set->misc_calcintegral )
3737 {
3738 int s;
3739 const char* names[] = {
3740 "primal-dual",
3741 "primal-ref",
3742 "dual-ref"
3743 };
3744 SCIPmessageFPrintInfo(scip->messagehdlr, file, "Integrals : Total Avg%%\n");
3746 {
3747 for( s = 0; s < 3; ++s )
3748 {
3749 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17s: %10s %10s (problem infeasible)\n",
3750 names[s], "-", "-");
3751 }
3752 }
3753 else
3754 {
3755 SCIP_Real integrals[3];
3756 SCIP_Real solvingtime = SCIPgetSolvingTime(scip);
3757
3758 if( !SCIPisFeasZero(scip, solvingtime) )
3759 {
3760 integrals[0] = SCIPstatGetPrimalDualIntegral(scip->stat, scip->set, scip->transprob, scip->origprob, TRUE);
3761
3762 if( scip->set->misc_referencevalue != SCIP_INVALID ) /*lint !e777*/
3763 {
3764 integrals[1] = SCIPstatGetPrimalReferenceIntegral(scip->stat, scip->set, scip->transprob, scip->origprob, FALSE);
3765 integrals[2] = SCIPstatGetDualReferenceIntegral(scip->stat, scip->set, scip->transprob, scip->origprob, FALSE);
3766 }
3767 else
3769 }
3770 else
3771 {
3773 }
3774
3775 /* print integrals, if computed */
3776 for( s = 0; s < 3; ++s )
3777 {
3778 if( integrals[s] == SCIP_INVALID ) /*lint !e777*/
3779 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17s: - - (not evaluated)\n", names[s]);
3780 else
3781 {
3782 SCIP_Real avg = integrals[s] / MAX(solvingtime,1e-6);
3783
3784 /* caution: this assert is non-deterministic since it depends on the solving time */
3785 assert(0.0 <= avg && SCIPisLE(scip, avg, 100.0));
3786 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17s: %10.2f %10.2f\n", names[s], integrals[s], avg);
3787 }
3788 }
3789 }
3790 }
3791}
3792
3793/** outputs concurrent solver statistics
3794 *
3795 * @pre This method can be called if SCIP is in one of the following stages:
3796 * - \ref SCIP_STAGE_TRANSFORMED
3797 * - \ref SCIP_STAGE_INITPRESOLVE
3798 * - \ref SCIP_STAGE_PRESOLVING
3799 * - \ref SCIP_STAGE_EXITPRESOLVE
3800 * - \ref SCIP_STAGE_PRESOLVED
3801 * - \ref SCIP_STAGE_SOLVING
3802 * - \ref SCIP_STAGE_SOLVED
3803 */
3805 SCIP* scip, /**< SCIP data structure */
3806 FILE* file /**< output file */
3807 )
3808{
3809 SCIP_CONCSOLVER** concsolvers;
3810 int nconcsolvers;
3811 int i;
3812 int winner;
3813
3814 assert(scip != NULL);
3815 assert(scip->set != NULL);
3816
3817 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintConcsolverStatistics", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3818
3819 if( !SCIPsyncstoreIsInitialized(scip->syncstore) )
3820 return;
3821
3822 nconcsolvers = SCIPgetNConcurrentSolvers(scip);
3823 concsolvers = SCIPgetConcurrentSolvers(scip);
3824 winner = SCIPsyncstoreGetWinner(scip->syncstore);
3825
3826 if( nconcsolvers > 0 )
3827 {
3828 SCIPmessageFPrintInfo(scip->messagehdlr, file, "Concurrent Solvers : SolvingTime SyncTime Nodes LP Iters SolsShared SolsRecvd TighterBnds TighterIntBnds\n");
3829 for( i = 0; i < nconcsolvers; ++i )
3830 {
3831 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %c%-16s: %11.2f %11.2f %11" SCIP_LONGINT_FORMAT " %11" SCIP_LONGINT_FORMAT "%11" SCIP_LONGINT_FORMAT " %11" SCIP_LONGINT_FORMAT " %11" SCIP_LONGINT_FORMAT " %14" SCIP_LONGINT_FORMAT "\n",
3832 winner == i ? '*' : ' ',
3833 SCIPconcsolverGetName(concsolvers[i]),
3834 SCIPconcsolverGetSolvingTime(concsolvers[i]),
3835 SCIPconcsolverGetSyncTime(concsolvers[i]),
3836 SCIPconcsolverGetNNodes(concsolvers[i]),
3837 SCIPconcsolverGetNLPIterations(concsolvers[i]),
3838 SCIPconcsolverGetNSolsShared(concsolvers[i]),
3839 SCIPconcsolverGetNSolsRecvd(concsolvers[i]),
3840 SCIPconcsolverGetNTighterBnds(concsolvers[i]),
3842 );
3843 }
3844 }
3845}
3846
3847/** display Benders' decomposition statistics */
3849 SCIP* scip, /**< SCIP data structure */
3850 FILE* file /**< output file */
3851 )
3852{
3853 SCIP_BENDERS** benders;
3854 int nbenders;
3855 int i;
3856
3857 assert(scip != NULL);
3858 assert(scip->set != NULL);
3859
3860 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintBendersStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3861
3862 if( SCIPgetNActiveBenders(scip) == 0 )
3863 return;
3864
3865 nbenders = SCIPgetNBenders(scip);
3866 benders = SCIPgetBenders(scip);
3867
3868 SCIPmessageFPrintInfo(scip->messagehdlr, file, "Benders Decomp : ExecTime SetupTime Calls Found Transfer StrCalls StrFails StrCuts\n");
3869 for( i = 0; i < nbenders; ++i )
3870 {
3871 if( SCIPbendersIsActive(benders[i]) )
3872 {
3873 SCIP_BENDERSCUT** benderscuts;
3874 int nbenderscuts;
3875 int j;
3876
3877 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17.17s: %10.2f %10.2f %10d %10d %10d %10d %10d %10d\n",
3878 SCIPbendersGetName(scip->set->benders[i]),
3879 SCIPbendersGetTime(scip->set->benders[i]),
3880 SCIPbendersGetSetupTime(scip->set->benders[i]),
3881 SCIPbendersGetNCalls(scip->set->benders[i]),
3882 SCIPbendersGetNCutsFound(scip->set->benders[i]),
3883 SCIPbendersGetNTransferredCuts(scip->set->benders[i]),
3884 SCIPbendersGetNStrengthenCalls(scip->set->benders[i]),
3885 SCIPbendersGetNStrengthenFails(scip->set->benders[i]),
3886 SCIPbendersGetNStrengthenCutsFound(scip->set->benders[i]));
3887
3888 nbenderscuts = SCIPbendersGetNBenderscuts(scip->set->benders[i]);
3889 benderscuts = SCIPbendersGetBenderscuts(scip->set->benders[i]);
3890
3891 for( j = 0; j < nbenderscuts; j++ )
3892 {
3893 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-15.17s: %10.2f %10.2f %10" SCIP_LONGINT_FORMAT " %10" SCIP_LONGINT_FORMAT " -\n",
3894 SCIPbenderscutGetName(benderscuts[j]),
3895 SCIPbenderscutGetTime(benderscuts[j]),
3896 SCIPbenderscutGetSetupTime(benderscuts[j]),
3897 SCIPbenderscutGetNCalls(benderscuts[j]),
3898 SCIPbenderscutGetNFound(benderscuts[j]));
3899 }
3900 }
3901 }
3902}
3903
3904/** outputs root statistics
3905 *
3906 * @pre This method can be called if SCIP is in one of the following stages:
3907 * - \ref SCIP_STAGE_SOLVING
3908 * - \ref SCIP_STAGE_SOLVED
3909 */
3911 SCIP* scip, /**< SCIP data structure */
3912 FILE* file /**< output file */
3913 )
3914{
3915 SCIP_Real dualboundroot;
3916 SCIP_Real firstdualboundroot;
3917 SCIP_Real firstlptime;
3918 SCIP_Real firstlpspeed;
3919
3920 assert(scip != NULL);
3921 assert(scip->stat != NULL);
3922 assert(scip->primal != NULL);
3923
3924 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintRootStatistics", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3925
3928 firstlptime = SCIPgetFirstLPTime(scip);
3929
3930 if( firstlptime > 0.0 )
3931 firstlpspeed = (SCIP_Real)scip->stat->nrootfirstlpiterations/firstlptime;
3932 else
3933 firstlpspeed = 0.0;
3934
3935 SCIPmessageFPrintInfo(scip->messagehdlr, file, "Root Node :\n");
3937 SCIPmessageFPrintInfo(scip->messagehdlr, file, " First LP value : -\n");
3938 else
3939 SCIPmessageFPrintInfo(scip->messagehdlr, file, " First LP value : %+21.14e\n", firstdualboundroot);
3940 if( firstlpspeed > 0.0 )
3941 SCIPmessageFPrintInfo(scip->messagehdlr, file, " First LP Iters : %10" SCIP_LONGINT_FORMAT " (%.2f Iter/sec)\n",
3942 scip->stat->nrootfirstlpiterations,
3943 (SCIP_Real)scip->stat->nrootfirstlpiterations/firstlptime);
3944 else
3945 SCIPmessageFPrintInfo(scip->messagehdlr, file, " First LP Iters : %10" SCIP_LONGINT_FORMAT "\n", scip->stat->nrootfirstlpiterations);
3946 SCIPmessageFPrintInfo(scip->messagehdlr, file, " First LP Time : %10.2f\n", firstlptime);
3947
3949 SCIPmessageFPrintInfo(scip->messagehdlr, file, " Final Dual Bound : -\n");
3950 else
3951 SCIPmessageFPrintInfo(scip->messagehdlr, file, " Final Dual Bound : %+21.14e\n", dualboundroot);
3952 SCIPmessageFPrintInfo(scip->messagehdlr, file, " Final Root Iters : %10" SCIP_LONGINT_FORMAT "\n", scip->stat->nrootlpiterations);
3953
3954 SCIPmessageFPrintInfo(scip->messagehdlr, file, " Root LP Estimate : ");
3955 if( scip->stat->rootlpbestestimate != SCIP_INVALID ) /*lint !e777*/
3956 {
3957 SCIPmessageFPrintInfo(scip->messagehdlr, file, "%+21.14e\n", SCIPretransformObj(scip, scip->stat->rootlpbestestimate));
3958 }
3959 else
3960 SCIPmessageFPrintInfo(scip->messagehdlr, file, "%21s\n","-");
3961}
3962
3963/** outputs timing statistics
3964 *
3965 * @pre This method can be called if SCIP is in one of the following stages:
3966 * - \ref SCIP_STAGE_PROBLEM
3967 * - \ref SCIP_STAGE_TRANSFORMED
3968 * - \ref SCIP_STAGE_INITPRESOLVE
3969 * - \ref SCIP_STAGE_PRESOLVING
3970 * - \ref SCIP_STAGE_EXITPRESOLVE
3971 * - \ref SCIP_STAGE_PRESOLVED
3972 * - \ref SCIP_STAGE_SOLVING
3973 * - \ref SCIP_STAGE_SOLVED
3974 */
3976 SCIP* scip, /**< SCIP data structure */
3977 FILE* file /**< output file */
3978 )
3979{
3980 SCIP_Real readingtime;
3981
3982 assert(scip != NULL);
3983 assert(scip->set != NULL);
3984
3985 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintTimingStatistics", FALSE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
3986
3987 readingtime = SCIPgetReadingTime(scip);
3988
3990 {
3991 SCIPmessageFPrintInfo(scip->messagehdlr, file, "Total Time : %10.2f\n", readingtime);
3992 SCIPmessageFPrintInfo(scip->messagehdlr, file, " reading : %10.2f\n", readingtime);
3993 }
3994 else
3995 {
3996 SCIP_Real totaltime;
3997 SCIP_Real solvingtime;
3998
3999 solvingtime = SCIPclockGetTime(scip->stat->solvingtime);
4000
4001 if( scip->set->time_reading )
4002 totaltime = solvingtime;
4003 else
4004 totaltime = solvingtime + readingtime;
4005
4006 SCIPmessageFPrintInfo(scip->messagehdlr, file, "Total Time : %10.2f\n", totaltime);
4007 SCIPmessageFPrintInfo(scip->messagehdlr, file, " solving : %10.2f\n", solvingtime);
4008 SCIPmessageFPrintInfo(scip->messagehdlr, file, " presolving : %10.2f (included in solving)\n", SCIPclockGetTime(scip->stat->presolvingtime));
4009 SCIPmessageFPrintInfo(scip->messagehdlr, file, " reading : %10.2f%s\n", readingtime, scip->set->time_reading ? " (included in solving)" : "");
4010
4011 if( scip->stat->ncopies > 0 )
4012 {
4013 SCIP_Real copytime;
4014
4015 copytime = SCIPclockGetTime(scip->stat->copyclock);
4016
4017 SCIPmessageFPrintInfo(scip->messagehdlr, file, " copying : %10.2f (%d #copies) (minimal %.2f, maximal %.2f, average %.2f)\n",
4018 copytime, scip->stat->ncopies, scip->stat->mincopytime, scip->stat->maxcopytime, copytime / scip->stat->ncopies);
4019 }
4020 else
4021 SCIPmessageFPrintInfo(scip->messagehdlr, file, " copying : %10.2f %s\n", 0.0, "(0 times copied the problem)");
4022 }
4023}
4024
4025/** outputs expression handler statistics
4026 *
4027 * @pre This method can be called if SCIP is in one of the following stages:
4028 * - \ref SCIP_STAGE_PROBLEM
4029 * - \ref SCIP_STAGE_TRANSFORMED
4030 * - \ref SCIP_STAGE_INITPRESOLVE
4031 * - \ref SCIP_STAGE_PRESOLVING
4032 * - \ref SCIP_STAGE_EXITPRESOLVE
4033 * - \ref SCIP_STAGE_PRESOLVED
4034 * - \ref SCIP_STAGE_SOLVING
4035 * - \ref SCIP_STAGE_SOLVED
4036 */
4038 SCIP* scip, /**< SCIP data structure */
4039 FILE* file /**< output file */
4040 )
4041{
4042 SCIP_Bool headerprinted = FALSE;
4043 int i;
4044
4045 assert(scip != NULL);
4046 assert(scip->set != NULL);
4047
4048 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintExpressionHandlerStatistics", FALSE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
4049
4050 for( i = 0; i < scip->set->nexprhdlrs; ++i )
4051 {
4052 SCIP_EXPRHDLR* exprhdlr = scip->set->exprhdlrs[i];
4053 assert(exprhdlr != NULL);
4054
4055 /* skip unused expression handler */
4056 if( SCIPexprhdlrGetNCreated(exprhdlr) == 0 )
4057 continue;
4058
4059 if( !headerprinted )
4060 {
4061 SCIPmessageFPrintInfo(scip->messagehdlr, file,
4062 "Expressions : %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s\n",
4063 "#IntEval", "IntEvalTi", "#RevProp", "RevPropTi", "DomReds", "Cutoffs", "#Estimate", "EstimTime", "Branching", "#Simplify", "SimplifyTi", "Simplified");
4065 }
4066
4067 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17s:", SCIPexprhdlrGetName(exprhdlr));
4068 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10lld", SCIPexprhdlrGetNIntevalCalls(exprhdlr));
4069 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f", SCIPexprhdlrGetIntevalTime(exprhdlr));
4070 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10lld", SCIPexprhdlrGetNReversepropCalls(exprhdlr));
4071 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f", SCIPexprhdlrGetReversepropTime(exprhdlr));
4072 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10lld", SCIPexprhdlrGetNDomainReductions(exprhdlr));
4073 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10lld", SCIPexprhdlrGetNCutoffs(exprhdlr));
4074 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10lld", SCIPexprhdlrGetNEstimateCalls(exprhdlr));
4075 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f", SCIPexprhdlrGetEstimateTime(exprhdlr));
4076 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10lld", SCIPexprhdlrGetNBranchings(exprhdlr));
4077 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10lld", SCIPexprhdlrGetNSimplifyCalls(exprhdlr));
4078 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f", SCIPexprhdlrGetSimplifyTime(exprhdlr));
4079 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10lld", SCIPexprhdlrGetNSimplifications(exprhdlr));
4080 SCIPmessageFPrintInfo(scip->messagehdlr, file, "\n");
4081 }
4082}
4083
4084/** outputs NLPI statistics
4085 *
4086 * @pre This method can be called if SCIP is in one of the following stages:
4087 * - \ref SCIP_STAGE_PROBLEM
4088 * - \ref SCIP_STAGE_TRANSFORMED
4089 * - \ref SCIP_STAGE_INITPRESOLVE
4090 * - \ref SCIP_STAGE_PRESOLVING
4091 * - \ref SCIP_STAGE_EXITPRESOLVE
4092 * - \ref SCIP_STAGE_PRESOLVED
4093 * - \ref SCIP_STAGE_SOLVING
4094 * - \ref SCIP_STAGE_SOLVED
4095 */
4097 SCIP* scip, /**< SCIP data structure */
4098 FILE* file /**< output file */
4099 )
4100{
4101 SCIP_Bool printedheader = FALSE;
4102 int i;
4103
4104 assert(scip != NULL);
4105 assert(scip->set != NULL);
4106
4107 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPprintNLPIStatistics", FALSE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
4108
4109 for( i = 0; i < scip->set->nnlpis; ++i )
4110 {
4111 SCIP_Real solvetime;
4112 SCIP_Real evaltime = 0.0;
4113 SCIP_Longint niter;
4114 SCIP_NLPI* nlpi;
4115 int j;
4116
4117 nlpi = scip->set->nlpis[i];
4118 assert(nlpi != NULL);
4119
4120 /* skip unused NLP solver */
4121 if( SCIPnlpiGetNProblems(nlpi) == 0 )
4122 continue;
4123
4124 if( !printedheader )
4125 {
4126 SCIPmessageFPrintInfo(scip->messagehdlr, file,
4127 "NLP Solvers : %10s %10s %10s %10s %s%10s %10s"
4128 " %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s"
4129 " %10s %10s %10s %10s %10s %10s %10s\n",
4130 "#Problems", "ProblemTi", "#Solves", "SolveTime",
4131 scip->set->time_nlpieval ? " EvalTime%" : "",
4132 "#Iter", "Time/Iter",
4133 "#Okay", "#TimeLimit", "#IterLimit", "#LObjLimit", "#Interrupt", "#NumError", "#EvalError", "#OutOfMem", "#LicenseEr", "#OtherTerm",
4134 "#GlobOpt", "#LocOpt", "#Feasible", "#LocInfeas", "#GlobInfea", "#Unbounded", "#Unknown"
4135 );
4137 }
4138
4139 solvetime = SCIPnlpiGetSolveTime(nlpi);
4140 if( scip->set->time_nlpieval )
4141 evaltime = SCIPnlpiGetEvalTime(nlpi);
4142 niter = SCIPnlpiGetNIterations(nlpi);
4143
4144 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %-17s:", SCIPnlpiGetName(nlpi));
4145 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10d", SCIPnlpiGetNProblems(nlpi));
4146 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f", SCIPnlpiGetProblemTime(nlpi));
4147 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10d", SCIPnlpiGetNSolves(nlpi));
4148 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f", solvetime);
4149 if( scip->set->time_nlpieval )
4150 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f", solvetime > 0.0 ? 100.0 * evaltime / solvetime : 0.0);
4151 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10" SCIP_LONGINT_FORMAT, niter);
4152 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10.2f", niter > 0 ? solvetime / niter : 0.0);
4153
4154 for( j = (int)SCIP_NLPTERMSTAT_OKAY; j <= (int)SCIP_NLPTERMSTAT_OTHER; ++j )
4155 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10d", SCIPnlpiGetNTermStat(nlpi, (SCIP_NLPTERMSTAT)j));
4156
4157 for( j = (int)SCIP_NLPSOLSTAT_GLOBOPT; j <= (int)SCIP_NLPSOLSTAT_UNKNOWN; ++j )
4158 SCIPmessageFPrintInfo(scip->messagehdlr, file, " %10d", SCIPnlpiGetNSolStat(nlpi, (SCIP_NLPSOLSTAT)j));
4159
4160 SCIPmessageFPrintInfo(scip->messagehdlr, file, "\n");
4161 }
4162}
4163
4164/** comparison method for statistics tables */
4165static
4170
4171/** outputs solving statistics
4172 *
4173 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4174 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4175 *
4176 * @note If limits have been changed between the solution and the call to this function, the status is recomputed and
4177 * thus may to correspond to the original status.
4178 *
4179 * @pre This method can be called if SCIP is in one of the following stages:
4180 * - \ref SCIP_STAGE_INIT
4181 * - \ref SCIP_STAGE_PROBLEM
4182 * - \ref SCIP_STAGE_TRANSFORMED
4183 * - \ref SCIP_STAGE_INITPRESOLVE
4184 * - \ref SCIP_STAGE_PRESOLVING
4185 * - \ref SCIP_STAGE_EXITPRESOLVE
4186 * - \ref SCIP_STAGE_PRESOLVED
4187 * - \ref SCIP_STAGE_SOLVING
4188 * - \ref SCIP_STAGE_SOLVED
4189 */
4191 SCIP* scip, /**< SCIP data structure */
4192 FILE* file /**< output file (or NULL for standard output) */
4193 )
4194{
4195 SCIP_TABLE** tables;
4196 int ntables;
4197 int i;
4198
4199 assert(scip != NULL);
4200 assert(scip->set != NULL);
4201
4202 SCIP_CALL( SCIPcheckStage(scip, "SCIPprintStatistics", TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
4203
4204 ntables = SCIPgetNTables(scip);
4205 tables = SCIPgetTables(scip);
4206
4207 /* sort all tables by position unless this has already been done */
4208 if( ! scip->set->tablessorted )
4209 {
4210 SCIPsortPtr((void**)tables, tablePosComp, ntables);
4211
4212 scip->set->tablessorted = TRUE;
4213 }
4214
4215 for( i = 0; i < ntables; ++i )
4216 {
4217 /* skip tables which are not active or only used in later stages */
4218 if( ( ! SCIPtableIsActive(tables[i]) ) || SCIPtableGetEarliestStage(tables[i]) > SCIPgetStage(scip) )
4219 continue;
4220
4221 SCIP_CALL( SCIPtableOutput(tables[i], scip->set, file) );
4222 }
4223
4224 return SCIP_OKAY;
4225}
4226
4227/** outputs reoptimization statistics
4228 *
4229 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4230 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4231 *
4232 * @pre This method can be called if SCIP is in one of the following stages:
4233 * - \ref SCIP_STAGE_INIT
4234 * - \ref SCIP_STAGE_PROBLEM
4235 * - \ref SCIP_STAGE_TRANSFORMED
4236 * - \ref SCIP_STAGE_INITPRESOLVE
4237 * - \ref SCIP_STAGE_PRESOLVING
4238 * - \ref SCIP_STAGE_EXITPRESOLVE
4239 * - \ref SCIP_STAGE_PRESOLVED
4240 * - \ref SCIP_STAGE_SOLVING
4241 * - \ref SCIP_STAGE_SOLVED
4242 */
4244 SCIP* scip, /**< SCIP data structure */
4245 FILE* file /**< output file (or NULL for standard output) */
4246 )
4247{
4248 SCIP_Real solving;
4249 SCIP_Real presolving;
4250 SCIP_Real updatetime;
4251
4252 SCIP_CALL( SCIPcheckStage(scip, "SCIPprintReoptStatistics", TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
4253
4254 assert(scip != NULL);
4255
4256 /* skip if reoptimization is disabled */
4257 if( !scip->set->reopt_enable )
4258 return SCIP_OKAY;
4259
4260 /* skip if not problem yet */
4261 if( scip->stat == NULL )
4262 return SCIP_OKAY;
4263
4264 solving = SCIPclockGetTime(scip->stat->solvingtimeoverall);
4265 presolving = SCIPclockGetTime(scip->stat->presolvingtimeoverall);
4266 updatetime = SCIPclockGetTime(scip->stat->reoptupdatetime);
4267
4268 SCIPmessageFPrintInfo(scip->messagehdlr, file, "SCIP Reopt Status : finished after %d runs.\n", scip->stat->nreoptruns);
4269 SCIPmessageFPrintInfo(scip->messagehdlr, file, "Time (sec) :\n");
4270 SCIPmessageFPrintInfo(scip->messagehdlr, file, " solving : %10.2f\n", solving);
4271 SCIPmessageFPrintInfo(scip->messagehdlr, file, " presolving : %10.2f (included in solving)\n", presolving);
4272 SCIPmessageFPrintInfo(scip->messagehdlr, file, " save time : %10.2f\n", SCIPreoptGetSavingtime(scip->reopt));
4273 SCIPmessageFPrintInfo(scip->messagehdlr, file, " update time : %10.2f\n", updatetime);
4274 SCIPmessageFPrintInfo(scip->messagehdlr, file, "Nodes : feas infeas pruned cutoff\n");
4275 SCIPmessageFPrintInfo(scip->messagehdlr, file, " total : %10d %10d %10d %10d\n",
4278 if( scip->stat->nreoptruns > 0 )
4279 {
4280 SCIPmessageFPrintInfo(scip->messagehdlr, file, " avg : %10.2f %10.2f %10.2f %10.2f\n",
4281 (SCIP_Real)SCIPreoptGetNTotalFeasNodes(scip->reopt)/scip->stat->nreoptruns,
4282 (SCIP_Real)SCIPreoptGetNTotalInfNodes(scip->reopt)/scip->stat->nreoptruns,
4283 (SCIP_Real)SCIPreoptGetNTotalPrunedNodes(scip->reopt)/scip->stat->nreoptruns,
4284 (SCIP_Real)SCIPreoptGetNTotalCutoffReoptnodes(scip->reopt)/scip->stat->nreoptruns);
4285 }
4286 else
4287 {
4288 SCIPmessageFPrintInfo(scip->messagehdlr, file, " avg : %10s %10s %10s %10s\n", "--", "--", "--", "--");
4289 }
4290 SCIPmessageFPrintInfo(scip->messagehdlr, file, "Restarts : global local\n");
4291 SCIPmessageFPrintInfo(scip->messagehdlr, file, " first : %10d --\n", SCIPreoptGetFirstRestarts(scip->reopt));
4292 SCIPmessageFPrintInfo(scip->messagehdlr, file, " last : %10d --\n", SCIPreoptGetLastRestarts(scip->reopt));
4293 SCIPmessageFPrintInfo(scip->messagehdlr, file, " total : %10d %10d\n", SCIPreoptGetNRestartsGlobal(scip->reopt),
4295 if( scip->stat->nreoptruns > 0 )
4296 {
4297 SCIPmessageFPrintInfo(scip->messagehdlr, file, " avg : -- %10.2f\n",
4298 (SCIP_Real)SCIPreoptGetNTotalRestartsLocal(scip->reopt)/scip->stat->nreoptruns);
4299 }
4300 else
4301 {
4302 SCIPmessageFPrintInfo(scip->messagehdlr, file, " avg : -- %10s\n", "--");
4303 }
4304
4305 return SCIP_OKAY;
4306}
4307
4308/** outputs history statistics about branchings on variables
4309 *
4310 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4311 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4312 *
4313 * @pre This method can be called if SCIP is in one of the following stages:
4314 * - \ref SCIP_STAGE_INIT
4315 * - \ref SCIP_STAGE_PROBLEM
4316 * - \ref SCIP_STAGE_TRANSFORMED
4317 * - \ref SCIP_STAGE_INITPRESOLVE
4318 * - \ref SCIP_STAGE_PRESOLVING
4319 * - \ref SCIP_STAGE_EXITPRESOLVE
4320 * - \ref SCIP_STAGE_PRESOLVED
4321 * - \ref SCIP_STAGE_SOLVING
4322 * - \ref SCIP_STAGE_SOLVED
4323 */
4325 SCIP* scip, /**< SCIP data structure */
4326 FILE* file /**< output file (or NULL for standard output) */
4327 )
4328{
4329 SCIP_VAR** vars;
4331 int v;
4332
4333 SCIP_CALL( SCIPcheckStage(scip, "SCIPprintBranchingStatistics", TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
4334
4335 switch( scip->set->stage )
4336 {
4337 case SCIP_STAGE_INIT:
4338 case SCIP_STAGE_PROBLEM:
4339 SCIPmessageFPrintInfo(scip->messagehdlr, file, "problem not yet solved. branching statistics not available.\n");
4340 return SCIP_OKAY;
4341
4347 case SCIP_STAGE_SOLVING:
4348 case SCIP_STAGE_SOLVED:
4349 SCIP_CALL( SCIPallocBufferArray(scip, &vars, scip->transprob->nvars) );
4350 for( v = 0; v < scip->transprob->nvars; ++v )
4351 {
4352 SCIP_VAR* var;
4353 int i;
4354
4355 var = scip->transprob->vars[v];
4356 for( i = v; i > 0 && strcmp(SCIPvarGetName(var), SCIPvarGetName(vars[i-1])) < 0; i-- )
4357 vars[i] = vars[i-1];
4358 vars[i] = var;
4359 }
4360
4361 SCIPmessageFPrintInfo(scip->messagehdlr, file, " locks branchings inferences cutoffs LP gain pscostcount gain variance \n");
4362 SCIPmessageFPrintInfo(scip->messagehdlr, file, "variable prio factor down up depth down up sb down up down up down up down up down up\n");
4363
4365 for( v = 0; v < scip->transprob->nvars; ++v )
4366 {
4369 || SCIPgetVarNStrongbranchs(scip, vars[v]) > 0 )
4370 {
4371 int nstrongbranchs;
4372
4373 nstrongbranchs = SCIPgetVarNStrongbranchs(scip, vars[v]);
4374 totalnstrongbranchs += nstrongbranchs;
4375 SCIPmessageFPrintInfo(scip->messagehdlr, file, "%-16s %5d %8.1f %6d %6d %6.1f %7" SCIP_LONGINT_FORMAT " %7" SCIP_LONGINT_FORMAT " %5d %8.1f %8.1f %5.1f%% %5.1f%% %15.4f %15.4f %7.1f %7.1f %15.2f %15.2f\n",
4376 SCIPvarGetName(vars[v]),
4385 nstrongbranchs,
4390 SCIPvarGetPseudocost(vars[v], scip->stat, -1.0),
4391 SCIPvarGetPseudocost(vars[v], scip->stat, +1.0),
4396 }
4397 }
4398 SCIPmessageFPrintInfo(scip->messagehdlr, file, "total %7" SCIP_LONGINT_FORMAT " %7" SCIP_LONGINT_FORMAT " %5d %8.1f %8.1f %5.1f%% %5.1f%% %15.4f %15.4f %7.1f %7.1f %15.2f %15.2f\n",
4404 / (SCIP_Real)SCIPhistoryGetNBranchings(scip->stat->glbhistory, SCIP_BRANCHDIR_DOWNWARDS) : 0.0,
4414 SCIPhistoryGetPseudocost(scip->stat->glbhistory, -1.0),
4415 SCIPhistoryGetPseudocost(scip->stat->glbhistory, +1.0),
4420
4422
4423 return SCIP_OKAY;
4424
4425 default:
4426 SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
4427 return SCIP_INVALIDCALL;
4428 } /*lint !e788*/
4429}
4430
4431/** outputs node information display line
4432 *
4433 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4434 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4435 *
4436 * @pre This method can be called if SCIP is in one of the following stages:
4437 * - \ref SCIP_STAGE_SOLVING
4438 */
4440 SCIP* scip, /**< SCIP data structure */
4441 FILE* file, /**< output file (or NULL for standard output) */
4442 SCIP_VERBLEVEL verblevel, /**< minimal verbosity level to actually display the information line */
4443 SCIP_Bool endline /**< should the line be terminated with a newline symbol? */
4444 )
4445{
4446 SCIP_CALL( SCIPcheckStage(scip, "SCIPprintDisplayLine", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
4447
4448 if( (SCIP_VERBLEVEL)scip->set->disp_verblevel >= verblevel )
4449 {
4450 SCIP_CALL( SCIPdispPrintLine(scip->set, scip->messagehdlr, scip->stat, file, TRUE, endline) );
4451 }
4452
4453 return SCIP_OKAY;
4454}
4455
4456/** gets total number of implications between variables that are stored in the implication graph
4457 *
4458 * @return the total number of implications between variables that are stored in the implication graph
4459 *
4460 * @pre This method can be called if SCIP is in one of the following stages:
4461 * - \ref SCIP_STAGE_INITPRESOLVE
4462 * - \ref SCIP_STAGE_PRESOLVING
4463 * - \ref SCIP_STAGE_EXITPRESOLVE
4464 * - \ref SCIP_STAGE_PRESOLVED
4465 * - \ref SCIP_STAGE_INITSOLVE
4466 * - \ref SCIP_STAGE_SOLVING
4467 * - \ref SCIP_STAGE_SOLVED
4468 */
4470 SCIP* scip /**< SCIP data structure */
4471 )
4472{
4473 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNImplications", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE) );
4474
4475 return scip->stat->nimplications;
4476}
4477
4478/** stores conflict graph of binary variables' implications into a file, which can be used as input for the DOT tool
4479 *
4480 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4481 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4482 *
4483 * @pre This method can be called if SCIP is in one of the following stages:
4484 * - \ref SCIP_STAGE_TRANSFORMED
4485 * - \ref SCIP_STAGE_INITPRESOLVE
4486 * - \ref SCIP_STAGE_PRESOLVING
4487 * - \ref SCIP_STAGE_EXITPRESOLVE
4488 * - \ref SCIP_STAGE_PRESOLVED
4489 * - \ref SCIP_STAGE_INITSOLVE
4490 * - \ref SCIP_STAGE_SOLVING
4491 * - \ref SCIP_STAGE_SOLVED
4492 * - \ref SCIP_STAGE_EXITSOLVE
4493 *
4494 * @deprecated because binary implications are now stored as cliques, please use SCIPwriteCliqueGraph() instead
4495 *
4496 */ /*lint -e715*/
4498 SCIP* scip, /**< SCIP data structure */
4499 const char* filename /**< file name, or NULL for stdout */
4500 )
4501{ /*lint --e{715}*/
4502 SCIPwarningMessage(scip, "SCIPwriteImplicationConflictGraph() is deprecated and does not do anything anymore. All binary to binary implications are now stored in the clique data structure, which can be written to a GML formatted file via SCIPwriteCliqueGraph().\n");
4503
4504 return SCIP_OKAY;
4505}
4506
4507/** update statistical information when a new solution was found */
4509 SCIP* scip /**< SCIP data structure */
4510 )
4511{
4513
4514 if( scip->primal->nsols == 1 )
4515 scip->stat->firstsolgap = scip->stat->lastsolgap;
4516
4517 if( scip->set->stage == SCIP_STAGE_SOLVING && scip->set->misc_calcintegral )
4518 {
4520 }
4521}
4522
4523/** recomputes and returns the primal dual gap stored in the stats */
4526 SCIP* scip /**< SCIP data structure */
4527 )
4528{
4529 return SCIPstatGetPrimalDualIntegral(scip->stat, scip->set, scip->transprob, scip->origprob, TRUE);
4530}
SCIP_Real SCIPbranchGetScore(SCIP_SET *set, SCIP_VAR *var, SCIP_Real downgain, SCIP_Real upgain)
Definition branch.c:2190
internal methods for branching rules and branching candidate storage
SCIP_Real SCIPclockGetTime(SCIP_CLOCK *clck)
Definition clock.c:438
internal methods for clocks and timing issues
SCIP_Longint SCIPconcsolverGetNNodes(SCIP_CONCSOLVER *concsolver)
Definition concsolver.c:573
SCIP_Longint SCIPconcsolverGetNSolsRecvd(SCIP_CONCSOLVER *concsolver)
Definition concsolver.c:583
SCIP_Real SCIPconcsolverGetSyncTime(SCIP_CONCSOLVER *concsolver)
Definition concsolver.c:553
SCIP_Longint SCIPconcsolverGetNTighterIntBnds(SCIP_CONCSOLVER *concsolver)
Definition concsolver.c:613
SCIP_Real SCIPconcsolverGetSolvingTime(SCIP_CONCSOLVER *concsolver)
Definition concsolver.c:543
SCIP_Longint SCIPconcsolverGetNTighterBnds(SCIP_CONCSOLVER *concsolver)
Definition concsolver.c:603
SCIP_Longint SCIPconcsolverGetNLPIterations(SCIP_CONCSOLVER *concsolver)
Definition concsolver.c:563
char * SCIPconcsolverGetName(SCIP_CONCSOLVER *concsolver)
Definition concsolver.c:300
SCIP_Longint SCIPconcsolverGetNSolsShared(SCIP_CONCSOLVER *concsolver)
Definition concsolver.c:593
datastructures for concurrent solvers
SCIP_CONCSOLVER ** SCIPgetConcurrentSolvers(SCIP *scip)
Definition concurrent.c:128
int SCIPgetNConcurrentSolvers(SCIP *scip)
Definition concurrent.c:117
helper functions for concurrent scip solvers
internal methods for conflict analysis
int SCIPconflictGetNConflicts(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNAppliedGlobalConss(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNDualproofsInfLocal(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNAppliedLocalLiterals(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNPropCalls(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNDualproofsInfNonzeros(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNStrongbranchIterations(SCIP_CONFLICT *conflict)
SCIP_Real SCIPconflictGetInfeasibleLPTime(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNInfeasibleLPCalls(SCIP_CONFLICT *conflict)
SCIP_Real SCIPconflictGetGlobalApplTime(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNInfeasibleLPSuccess(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNBoundexceedingLPReconvergenceConss(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNGlobalChgBds(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNPropConflictLiterals(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNAppliedConss(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNInfeasibleLPConflictConss(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNBoundexceedingLPConflictConss(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNBoundexceedingLPSuccess(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNStrongbranchCalls(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNInfeasibleLPReconvergenceLiterals(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNPropReconvergenceConss(SCIP_CONFLICT *conflict)
SCIP_Real SCIPconflictGetBoundexceedingLPTime(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNStrongbranchReconvergenceLiterals(SCIP_CONFLICT *conflict)
SCIP_Real SCIPconflictGetPseudoTime(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNPseudoReconvergenceLiterals(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNPropReconvergenceLiterals(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNInfeasibleLPReconvergenceConss(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNAppliedLocalConss(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNStrongbranchReconvergenceConss(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNBoundexceedingLPConflictLiterals(SCIP_CONFLICT *conflict)
SCIP_Real SCIPconflictGetStrongbranchTime(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNPseudoSuccess(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNInfeasibleLPConflictLiterals(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNPseudoConflictLiterals(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNLocalChgBds(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNDualproofsBndSuccess(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNPropSuccess(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNDualproofsInfSuccess(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNBoundexceedingLPCalls(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNPropConflictConss(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNStrongbranchSuccess(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNDualproofsBndGlobal(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNPseudoReconvergenceConss(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNAppliedGlobalLiterals(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNDualproofsBndLocal(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNPseudoCalls(SCIP_CONFLICT *conflict)
SCIP_Real SCIPconflictGetPropTime(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNBoundexceedingLPIterations(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNStrongbranchConflictLiterals(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNPseudoConflictConss(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNDualproofsBndNonzeros(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNDualproofsInfGlobal(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNBoundexceedingLPReconvergenceLiterals(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNStrongbranchConflictConss(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNInfeasibleLPIterations(SCIP_CONFLICT *conflict)
int SCIPconflictstoreGetMaxPoolSize(SCIP_CONFLICTSTORE *conflictstore)
int SCIPconflictstoreGetInitPoolSize(SCIP_CONFLICTSTORE *conflictstore)
internal methods for storing conflicts
SCIP_RETCODE SCIPcheckStage(SCIP *scip, const char *method, SCIP_Bool init, SCIP_Bool problem, SCIP_Bool transforming, SCIP_Bool transformed, SCIP_Bool initpresolve, SCIP_Bool presolving, SCIP_Bool exitpresolve, SCIP_Bool presolved, SCIP_Bool initsolve, SCIP_Bool solving, SCIP_Bool solved, SCIP_Bool exitsolve, SCIP_Bool freetrans, SCIP_Bool freescip)
Definition debug.c:2208
methods for debugging
#define NULL
Definition def.h:267
#define SCIP_MAXSTRLEN
Definition def.h:288
#define SCIP_INVALID
Definition def.h:193
#define SCIP_Real
Definition def.h:173
#define TRUE
Definition def.h:93
#define FALSE
Definition def.h:94
#define MAX(x, y)
Definition def.h:239
#define SCIP_CALL_ABORT(x)
Definition def.h:353
#define SCIP_LONGINT_FORMAT
Definition def.h:165
#define REALABS(x)
Definition def.h:197
#define SCIP_CALL(x)
Definition def.h:374
SCIP_RETCODE SCIPdispPrintLine(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, FILE *file, SCIP_Bool forcedisplay, SCIP_Bool endline)
Definition disp.c:415
internal methods for displaying runtime statistics
#define nnodes
Definition gastrans.c:74
SCIP_RETCODE SCIPprintStage(SCIP *scip, FILE *file)
SCIP_STATUS SCIPgetStatus(SCIP *scip)
SCIP_STAGE SCIPgetStage(SCIP *scip)
void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)
SCIP_Real SCIPcomputeGap(SCIP_Real eps, SCIP_Real inf, SCIP_Real primalbound, SCIP_Real dualbound)
Definition misc.c:11202
int SCIPgetNActiveBenders(SCIP *scip)
SCIP_Real SCIPbendersGetSetupTime(SCIP_BENDERS *benders)
Definition benders.c:6040
int SCIPbendersGetNTransferredCuts(SCIP_BENDERS *benders)
Definition benders.c:6701
int SCIPbendersGetNStrengthenFails(SCIP_BENDERS *benders)
Definition benders.c:6030
SCIP_BENDERS ** SCIPgetBenders(SCIP *scip)
int SCIPgetNBenders(SCIP *scip)
int SCIPbendersGetNStrengthenCalls(SCIP_BENDERS *benders)
Definition benders.c:6020
int SCIPbendersGetNBenderscuts(SCIP_BENDERS *benders)
Definition benders.c:6956
SCIP_Bool SCIPbendersIsActive(SCIP_BENDERS *benders)
Definition benders.c:2675
const char * SCIPbendersGetName(SCIP_BENDERS *benders)
Definition benders.c:5924
int SCIPbendersGetNStrengthenCutsFound(SCIP_BENDERS *benders)
Definition benders.c:6010
int SCIPbendersGetNCalls(SCIP_BENDERS *benders)
Definition benders.c:5990
int SCIPbendersGetNCutsFound(SCIP_BENDERS *benders)
Definition benders.c:6000
SCIP_Real SCIPbendersGetTime(SCIP_BENDERS *benders)
Definition benders.c:6050
SCIP_BENDERSCUT ** SCIPbendersGetBenderscuts(SCIP_BENDERS *benders)
Definition benders.c:6939
const char * SCIPbenderscutGetName(SCIP_BENDERSCUT *benderscut)
Definition benderscut.c:492
SCIP_Longint SCIPbenderscutGetNCalls(SCIP_BENDERSCUT *benderscut)
Definition benderscut.c:533
SCIP_Real SCIPbenderscutGetTime(SCIP_BENDERSCUT *benderscut)
Definition benderscut.c:573
SCIP_Real SCIPbenderscutGetSetupTime(SCIP_BENDERSCUT *benderscut)
Definition benderscut.c:563
SCIP_Longint SCIPbenderscutGetNFound(SCIP_BENDERSCUT *benderscut)
Definition benderscut.c:543
SCIP_Longint SCIPbranchruleGetNDomredsFound(SCIP_BRANCHRULE *branchrule)
Definition branch.c:2153
SCIP_Longint SCIPbranchruleGetNPseudoCalls(SCIP_BRANCHRULE *branchrule)
Definition branch.c:2111
SCIP_Longint SCIPbranchruleGetNConssFound(SCIP_BRANCHRULE *branchrule)
Definition branch.c:2143
SCIP_Longint SCIPbranchruleGetNLPCalls(SCIP_BRANCHRULE *branchrule)
Definition branch.c:2091
const char * SCIPbranchruleGetName(SCIP_BRANCHRULE *branchrule)
Definition branch.c:1971
SCIP_Longint SCIPbranchruleGetNChildren(SCIP_BRANCHRULE *branchrule)
Definition branch.c:2163
SCIP_Real SCIPbranchruleGetTime(SCIP_BRANCHRULE *branchrule)
Definition branch.c:2081
SCIP_Real SCIPbranchruleGetSetupTime(SCIP_BRANCHRULE *branchrule)
Definition branch.c:2071
SCIP_Longint SCIPbranchruleGetNCutoffs(SCIP_BRANCHRULE *branchrule)
Definition branch.c:2121
SCIP_Longint SCIPbranchruleGetNExternCalls(SCIP_BRANCHRULE *branchrule)
Definition branch.c:2101
SCIP_Longint SCIPbranchruleGetNCutsFound(SCIP_BRANCHRULE *branchrule)
Definition branch.c:2131
SCIP_Longint SCIPcomprGetNCalls(SCIP_COMPR *compr)
Definition compr.c:510
SCIP_Longint SCIPcomprGetNFound(SCIP_COMPR *compr)
Definition compr.c:520
SCIP_Real SCIPcomprGetSetupTime(SCIP_COMPR *compr)
Definition compr.c:540
SCIP_Real SCIPcomprGetTime(SCIP_COMPR *compr)
Definition compr.c:550
const char * SCIPcomprGetName(SCIP_COMPR *compr)
Definition compr.c:456
int SCIPconshdlrGetMaxNActiveConss(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4970
SCIP_Real SCIPconshdlrGetCheckTime(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4800
SCIP_Longint SCIPconshdlrGetNCheckCalls(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4870
int SCIPconshdlrGetNChgSides(SCIP_CONSHDLR *conshdlr)
Definition cons.c:5080
SCIP_Real SCIPconshdlrGetPresolTime(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4730
SCIP_Bool SCIPconshdlrDoesPresolve(SCIP_CONSHDLR *conshdlr)
Definition cons.c:5170
int SCIPconshdlrGetNFixedVars(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4990
SCIP_Real SCIPconshdlrGetEnfoLPTime(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4750
int SCIPconshdlrGetNPresolCalls(SCIP_CONSHDLR *conshdlr)
Definition cons.c:5090
SCIP_Longint SCIPconshdlrGetNDomredsFound(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4950
SCIP_Longint SCIPconshdlrGetNCutsApplied(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4910
int SCIPconshdlrGetNChgCoefs(SCIP_CONSHDLR *conshdlr)
Definition cons.c:5070
SCIP_Real SCIPconshdlrGetStrongBranchPropTime(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4790
SCIP_Longint SCIPconshdlrGetNCutsFound(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4900
SCIP_Real SCIPconshdlrGetPropTime(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4780
SCIP_Real SCIPconshdlrGetEnfoPSTime(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4760
SCIP_Longint SCIPconshdlrGetNCutoffs(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4890
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4197
SCIP_Longint SCIPconshdlrGetNSepaCalls(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4820
int SCIPconshdlrGetNDelConss(SCIP_CONSHDLR *conshdlr)
Definition cons.c:5040
SCIP_Longint SCIPconshdlrGetNChildren(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4960
SCIP_Real SCIPconshdlrGetEnfoRelaxTime(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4770
SCIP_Bool SCIPconshdlrNeedsCons(SCIP_CONSHDLR *conshdlr)
Definition cons.c:5160
int SCIPconshdlrGetNAggrVars(SCIP_CONSHDLR *conshdlr)
Definition cons.c:5000
SCIP_Longint SCIPconshdlrGetNEnfoPSCalls(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4840
int SCIPconshdlrGetNAddHoles(SCIP_CONSHDLR *conshdlr)
Definition cons.c:5030
int SCIPconshdlrGetNUpgdConss(SCIP_CONSHDLR *conshdlr)
Definition cons.c:5060
int SCIPconshdlrGetStartNActiveConss(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4980
int SCIPconshdlrGetNAddConss(SCIP_CONSHDLR *conshdlr)
Definition cons.c:5050
int SCIPconshdlrGetNChgBds(SCIP_CONSHDLR *conshdlr)
Definition cons.c:5020
SCIP_Longint SCIPconshdlrGetNConssFound(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4940
SCIP_Longint SCIPconshdlrGetNPropCalls(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4860
SCIP_Longint SCIPconshdlrGetNEnfoLPCalls(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4830
SCIP_Real SCIPconshdlrGetSetupTime(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4720
SCIP_Longint SCIPconshdlrGetNRespropCalls(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4880
SCIP_Real SCIPconshdlrGetSepaTime(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4740
int SCIPconshdlrGetNChgVarTypes(SCIP_CONSHDLR *conshdlr)
Definition cons.c:5010
SCIP_Real SCIPconshdlrGetRespropTime(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4810
SCIP_Longint SCIPconshdlrGetNEnfoRelaxCalls(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4850
SCIP_Longint SCIPcutpoolGetNRootCalls(SCIP_CUTPOOL *cutpool)
Definition cutpool.c:1125
SCIP_Longint SCIPcutpoolGetNCutsFound(SCIP_CUTPOOL *cutpool)
Definition cutpool.c:1135
SCIP_Real SCIPcutpoolGetTime(SCIP_CUTPOOL *cutpool)
Definition cutpool.c:1105
SCIP_Longint SCIPcutpoolGetMaxNCuts(SCIP_CUTPOOL *cutpool)
Definition cutpool.c:1095
SCIP_Longint SCIPcutpoolGetNCalls(SCIP_CUTPOOL *cutpool)
Definition cutpool.c:1115
SCIP_Longint SCIPcutpoolGetNCutsAdded(SCIP_CUTPOOL *cutpool)
Definition cutpool.c:1145
SCIP_Longint SCIPcutselGetNLocalCuts(SCIP_CUTSEL *cutsel)
Definition cutsel.c:625
SCIP_Longint SCIPcutselGetNLocalCutsFiltered(SCIP_CUTSEL *cutsel)
Definition cutsel.c:645
SCIP_Longint SCIPcutselGetNRootCuts(SCIP_CUTSEL *cutsel)
Definition cutsel.c:595
SCIP_Longint SCIPcutselGetNRootForcedCuts(SCIP_CUTSEL *cutsel)
Definition cutsel.c:605
SCIP_Longint SCIPcutselGetNCalls(SCIP_CUTSEL *cutsel)
Definition cutsel.c:575
SCIP_Real SCIPcutselGetTime(SCIP_CUTSEL *cutsel)
Definition cutsel.c:565
const char * SCIPcutselGetName(SCIP_CUTSEL *cutsel)
Definition cutsel.c:159
SCIP_Longint SCIPcutselGetNRootCutsFiltered(SCIP_CUTSEL *cutsel)
Definition cutsel.c:615
SCIP_Real SCIPcutselGetSetupTime(SCIP_CUTSEL *cutsel)
Definition cutsel.c:555
SCIP_Longint SCIPcutselGetNLocalForcedCuts(SCIP_CUTSEL *cutsel)
Definition cutsel.c:635
SCIP_Longint SCIPcutselGetNRootCalls(SCIP_CUTSEL *cutsel)
Definition cutsel.c:585
SCIP_Longint SCIPdivesetGetNBacktracks(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)
Definition heur.c:615
SCIP_Longint SCIPdivesetGetNSols(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)
Definition heur.c:641
int SCIPdivesetGetMaxSolutionDepth(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)
Definition heur.c:563
SCIP_Longint SCIPdivesetGetNConflicts(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)
Definition heur.c:628
SCIP_Real SCIPdivesetGetAvgSolutionDepth(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)
Definition heur.c:576
int SCIPdivesetGetMaxDepth(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)
Definition heur.c:524
int SCIPdivesetGetMinDepth(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)
Definition heur.c:511
SCIP_Real SCIPdivesetGetAvgDepth(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)
Definition heur.c:537
SCIP_Longint SCIPdivesetGetNLPIterations(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)
Definition heur.c:589
int SCIPdivesetGetMinSolutionDepth(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)
Definition heur.c:550
const char * SCIPdivesetGetName(SCIP_DIVESET *diveset)
Definition heur.c:445
int SCIPdivesetGetNCalls(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)
Definition heur.c:485
SCIP_Longint SCIPdivesetGetNProbingNodes(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)
Definition heur.c:602
int SCIPdivesetGetNSolutionCalls(SCIP_DIVESET *diveset, SCIP_DIVECONTEXT divecontext)
Definition heur.c:498
const char * SCIPexprhdlrGetName(SCIP_EXPRHDLR *exprhdlr)
Definition expr.c:545
SCIP_Real SCIPexprhdlrGetEstimateTime(SCIP_EXPRHDLR *exprhdlr)
Definition expr.c:793
SCIP_Longint SCIPexprhdlrGetNDomainReductions(SCIP_EXPRHDLR *exprhdlr)
Definition expr.c:761
SCIP_Real SCIPexprhdlrGetReversepropTime(SCIP_EXPRHDLR *exprhdlr)
Definition expr.c:741
SCIP_Longint SCIPexprhdlrGetNReversepropCalls(SCIP_EXPRHDLR *exprhdlr)
Definition expr.c:731
unsigned int SCIPexprhdlrGetNCreated(SCIP_EXPRHDLR *exprhdlr)
Definition expr.c:701
SCIP_Longint SCIPexprhdlrGetNBranchings(SCIP_EXPRHDLR *exprhdlr)
Definition expr.c:807
SCIP_Longint SCIPexprhdlrGetNSimplifyCalls(SCIP_EXPRHDLR *exprhdlr)
Definition expr.c:827
SCIP_Real SCIPexprhdlrGetIntevalTime(SCIP_EXPRHDLR *exprhdlr)
Definition expr.c:721
SCIP_Real SCIPexprhdlrGetSimplifyTime(SCIP_EXPRHDLR *exprhdlr)
Definition expr.c:837
SCIP_Longint SCIPexprhdlrGetNIntevalCalls(SCIP_EXPRHDLR *exprhdlr)
Definition expr.c:711
SCIP_Longint SCIPexprhdlrGetNSimplifications(SCIP_EXPRHDLR *exprhdlr)
Definition expr.c:847
SCIP_Longint SCIPexprhdlrGetNCutoffs(SCIP_EXPRHDLR *exprhdlr)
Definition expr.c:751
SCIP_Longint SCIPexprhdlrGetNEstimateCalls(SCIP_EXPRHDLR *exprhdlr)
Definition expr.c:783
SCIP_Longint SCIPheurGetNSolsFound(SCIP_HEUR *heur)
Definition heur.c:1589
SCIP_Longint SCIPheurGetNBestSolsFound(SCIP_HEUR *heur)
Definition heur.c:1599
SCIP_Longint SCIPheurGetNCalls(SCIP_HEUR *heur)
Definition heur.c:1579
SCIP_Real SCIPheurGetSetupTime(SCIP_HEUR *heur)
Definition heur.c:1631
int SCIPheurGetNDivesets(SCIP_HEUR *heur)
Definition heur.c:1661
SCIP_Real SCIPheurGetTime(SCIP_HEUR *heur)
Definition heur.c:1641
const char * SCIPheurGetName(SCIP_HEUR *heur)
Definition heur.c:1453
SCIP_DIVESET ** SCIPheurGetDivesets(SCIP_HEUR *heur)
Definition heur.c:1651
#define SCIPallocBufferArray(scip, ptr, num)
Definition scip_mem.h:124
#define SCIPfreeBufferArray(scip, ptr)
Definition scip_mem.h:136
int SCIPnlpiGetNSolves(SCIP_NLPI *nlpi)
Definition nlpi.c:774
SCIP_Real SCIPnlpiGetProblemTime(SCIP_NLPI *nlpi)
Definition nlpi.c:765
SCIP_Real SCIPnlpiGetSolveTime(SCIP_NLPI *nlpi)
Definition nlpi.c:783
int SCIPnlpiGetNTermStat(SCIP_NLPI *nlpi, SCIP_NLPTERMSTAT termstatus)
Definition nlpi.c:813
SCIP_Longint SCIPnlpiGetNIterations(SCIP_NLPI *nlpi)
Definition nlpi.c:804
int SCIPnlpiGetNProblems(SCIP_NLPI *nlpi)
Definition nlpi.c:756
int SCIPnlpiGetNSolStat(SCIP_NLPI *nlpi, SCIP_NLPSOLSTAT solstatus)
Definition nlpi.c:823
const char * SCIPnlpiGetName(SCIP_NLPI *nlpi)
Definition nlpi.c:722
SCIP_Real SCIPnlpiGetEvalTime(SCIP_NLPI *nlpi)
Definition nlpi.c:795
SCIP_RETCODE SCIPgetNLPNlRowsStat(SCIP *scip, int *nlinear, int *nconvexineq, int *nnonconvexineq, int *nnonlineareq)
Definition scip_nlp.c:369
SCIP_Real SCIPpresolGetSetupTime(SCIP_PRESOL *presol)
Definition presol.c:697
int SCIPpresolGetNAggrVars(SCIP_PRESOL *presol)
Definition presol.c:727
int SCIPpresolGetNCalls(SCIP_PRESOL *presol)
Definition presol.c:817
int SCIPpresolGetNDelConss(SCIP_PRESOL *presol)
Definition presol.c:767
int SCIPpresolGetNChgCoefs(SCIP_PRESOL *presol)
Definition presol.c:797
int SCIPpresolGetNAddHoles(SCIP_PRESOL *presol)
Definition presol.c:757
SCIP_Real SCIPpresolGetTime(SCIP_PRESOL *presol)
Definition presol.c:707
int SCIPpresolGetNChgVarTypes(SCIP_PRESOL *presol)
Definition presol.c:737
int SCIPpresolGetNChgSides(SCIP_PRESOL *presol)
Definition presol.c:807
int SCIPpresolGetNFixedVars(SCIP_PRESOL *presol)
Definition presol.c:717
int SCIPpresolGetNChgBds(SCIP_PRESOL *presol)
Definition presol.c:747
int SCIPpresolGetNAddConss(SCIP_PRESOL *presol)
Definition presol.c:777
const char * SCIPpresolGetName(SCIP_PRESOL *presol)
Definition presol.c:599
int SCIPpricerGetNVarsFound(SCIP_PRICER *pricer)
Definition pricer.c:654
const char * SCIPpricerGetName(SCIP_PRICER *pricer)
Definition pricer.c:600
SCIP_Real SCIPpricerGetSetupTime(SCIP_PRICER *pricer)
Definition pricer.c:664
SCIP_Real SCIPpricerGetTime(SCIP_PRICER *pricer)
Definition pricer.c:674
int SCIPpricerGetNCalls(SCIP_PRICER *pricer)
Definition pricer.c:644
SCIP_Bool SCIPpropDoesPresolve(SCIP_PROP *prop)
Definition prop.c:1286
SCIP_Real SCIPpropGetRespropTime(SCIP_PROP *prop)
Definition prop.c:1076
SCIP_Real SCIPpropGetPresolTime(SCIP_PROP *prop)
Definition prop.c:1086
SCIP_Longint SCIPpropGetNCutoffs(SCIP_PROP *prop)
Definition prop.c:1116
SCIP_Real SCIPpropGetSetupTime(SCIP_PROP *prop)
Definition prop.c:1034
int SCIPpropGetNAddHoles(SCIP_PROP *prop)
Definition prop.c:1206
int SCIPpropGetNChgBds(SCIP_PROP *prop)
Definition prop.c:1196
int SCIPpropGetNChgSides(SCIP_PROP *prop)
Definition prop.c:1256
int SCIPpropGetNPresolCalls(SCIP_PROP *prop)
Definition prop.c:1266
SCIP_Longint SCIPpropGetNRespropCalls(SCIP_PROP *prop)
Definition prop.c:1106
SCIP_Real SCIPpropGetStrongBranchPropTime(SCIP_PROP *prop)
Definition prop.c:1066
SCIP_Longint SCIPpropGetNDomredsFound(SCIP_PROP *prop)
Definition prop.c:1126
int SCIPpropGetNChgCoefs(SCIP_PROP *prop)
Definition prop.c:1246
int SCIPpropGetNAggrVars(SCIP_PROP *prop)
Definition prop.c:1176
int SCIPpropGetNFixedVars(SCIP_PROP *prop)
Definition prop.c:1166
const char * SCIPpropGetName(SCIP_PROP *prop)
Definition prop.c:941
int SCIPpropGetNAddConss(SCIP_PROP *prop)
Definition prop.c:1226
SCIP_Real SCIPpropGetTime(SCIP_PROP *prop)
Definition prop.c:1056
int SCIPpropGetNChgVarTypes(SCIP_PROP *prop)
Definition prop.c:1186
SCIP_Longint SCIPpropGetNCalls(SCIP_PROP *prop)
Definition prop.c:1096
int SCIPpropGetNDelConss(SCIP_PROP *prop)
Definition prop.c:1216
const char * SCIPreaderGetName(SCIP_READER *reader)
Definition reader.c:557
SCIP_Longint SCIPrelaxGetNAddedConss(SCIP_RELAX *relax)
Definition relax.c:658
SCIP_Real SCIPrelaxGetTime(SCIP_RELAX *relax)
Definition relax.c:618
const char * SCIPrelaxGetName(SCIP_RELAX *relax)
Definition relax.c:542
SCIP_Longint SCIPrelaxGetNCutoffs(SCIP_RELAX *relax)
Definition relax.c:638
SCIP_Longint SCIPrelaxGetNSeparatedCuts(SCIP_RELAX *relax)
Definition relax.c:688
SCIP_Longint SCIPrelaxGetNReducedDomains(SCIP_RELAX *relax)
Definition relax.c:678
SCIP_Real SCIPrelaxGetImprovedLowerboundTime(SCIP_RELAX *relax)
Definition relax.c:668
SCIP_Longint SCIPrelaxGetNImprovedLowerbound(SCIP_RELAX *relax)
Definition relax.c:648
SCIP_Longint SCIPrelaxGetNCalls(SCIP_RELAX *relax)
Definition relax.c:628
SCIP_Longint SCIPsepaGetNCutsApplied(SCIP_SEPA *sepa)
Definition sepa.c:941
SCIP_Longint SCIPsepaGetNCutoffs(SCIP_SEPA *sepa)
Definition sepa.c:890
SCIP_Longint SCIPsepaGetNCutsAppliedViaPool(SCIP_SEPA *sepa)
Definition sepa.c:951
SCIP_Longint SCIPsepaGetNCutsAppliedDirect(SCIP_SEPA *sepa)
Definition sepa.c:961
const char * SCIPsepaGetName(SCIP_SEPA *sepa)
Definition sepa.c:743
SCIP_Longint SCIPsepaGetNDomredsFound(SCIP_SEPA *sepa)
Definition sepa.c:1079
SCIP_Bool SCIPsepaIsParentsepa(SCIP_SEPA *sepa)
Definition sepa.c:1129
SCIP_Real SCIPsepaGetTime(SCIP_SEPA *sepa)
Definition sepa.c:850
SCIP_SEPA * SCIPsepaGetParentsepa(SCIP_SEPA *sepa)
Definition sepa.c:1139
SCIP_Longint SCIPsepaGetNCutsAddedViaPool(SCIP_SEPA *sepa)
Definition sepa.c:921
SCIP_Longint SCIPsepaGetNConssFound(SCIP_SEPA *sepa)
Definition sepa.c:1069
SCIP_Longint SCIPsepaGetNRootCalls(SCIP_SEPA *sepa)
Definition sepa.c:870
SCIP_Longint SCIPsepaGetNCutsAddedDirect(SCIP_SEPA *sepa)
Definition sepa.c:931
SCIP_Real SCIPsepaGetSetupTime(SCIP_SEPA *sepa)
Definition sepa.c:840
SCIP_Longint SCIPsepaGetNCutsFound(SCIP_SEPA *sepa)
Definition sepa.c:900
SCIP_Longint SCIPsepaGetNCalls(SCIP_SEPA *sepa)
Definition sepa.c:860
SCIP_Real SCIPsolGetTime(SCIP_SOL *sol)
Definition sol.c:2764
SCIP_Longint SCIPsolGetNodenum(SCIP_SOL *sol)
Definition sol.c:2784
SCIP_HEUR * SCIPsolGetHeur(SCIP_SOL *sol)
Definition sol.c:2804
int SCIPsolGetDepth(SCIP_SOL *sol)
Definition sol.c:2794
int SCIPsolGetRunnum(SCIP_SOL *sol)
Definition sol.c:2774
SCIP_Real SCIPretransformObj(SCIP *scip, SCIP_Real obj)
Definition scip_sol.c:1432
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)
void SCIPincAvgGMIeff(SCIP *scip, SCIP_Real gmieff)
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)
SCIP_Real SCIPgetAvgGMIeff(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_Real SCIPgetPrimalDualIntegral(SCIP *scip)
SCIP_Longint SCIPgetNPrimalLPs(SCIP *scip)
SCIP_Real SCIPgetAvgCutoffs(SCIP *scip, SCIP_BRANCHDIR dir)
SCIP_Longint SCIPgetNRootStrongbranchLPIterations(SCIP *scip)
SCIP_Real SCIPgetAvgCutoffScore(SCIP *scip)
int SCIPtableGetPosition(SCIP_TABLE *table)
Definition table.c:329
SCIP_TABLE ** SCIPgetTables(SCIP *scip)
Definition scip_table.c:107
int SCIPgetNTables(SCIP *scip)
Definition scip_table.c:118
SCIP_STAGE SCIPtableGetEarliestStage(SCIP_TABLE *table)
Definition table.c:339
SCIP_Bool SCIPtableIsActive(SCIP_TABLE *table)
Definition table.c:349
SCIP_Real SCIPgetFirstLPTime(SCIP *scip)
SCIP_Real SCIPgetSolvingTime(SCIP *scip)
SCIP_Real SCIPgetReadingTime(SCIP *scip)
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPvarGetAvgBranchdepth(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition var.c:15787
int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
Definition var.c:3353
const char * SCIPvarGetName(SCIP_VAR *var)
Definition var.c:17419
SCIP_Real SCIPvarGetBranchFactor(SCIP_VAR *var)
Definition var.c:18238
SCIP_Longint SCIPvarGetNBranchings(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition var.c:15699
int SCIPvarGetBranchPriority(SCIP_VAR *var)
Definition var.c:18250
int SCIPgetVarNStrongbranchs(SCIP *scip, SCIP_VAR *var)
Definition scip_var.c:4228
int SCIPvarGetNLocksDownType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
Definition var.c:3295
void SCIPsortPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
int SCIPsnprintf(char *t, int len, const char *s,...)
Definition misc.c:10877
return SCIP_OKAY
static SCIP_DIVESET * diveset
int c
assert(minobj< SCIPgetCutoffbound(scip))
SCIP_VAR * var
static SCIP_VAR ** vars
SCIP_Real SCIPhistoryGetPseudocost(SCIP_HISTORY *history, SCIP_Real solvaldelta)
Definition history.c:446
SCIP_Real SCIPhistoryGetAvgInferences(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
Definition history.c:665
SCIP_Longint SCIPhistoryGetNBranchings(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
Definition history.c:639
SCIP_Real SCIPhistoryGetAvgConflictlength(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
Definition history.c:578
SCIP_Real SCIPhistoryGetAvgCutoffs(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
Definition history.c:691
SCIP_Real SCIPhistoryGetCutoffSum(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
Definition history.c:678
SCIP_Real SCIPhistoryGetPseudocostCount(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
Definition history.c:484
SCIP_Real SCIPhistoryGetPseudocostVariance(SCIP_HISTORY *history, SCIP_BRANCHDIR direction)
Definition history.c:460
SCIP_Real SCIPhistoryGetVSIDS(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
Definition history.c:536
SCIP_Real SCIPhistoryGetAvgGMIeff(SCIP_HISTORY *history)
Definition history.c:749
SCIP_Real SCIPhistoryGetInferenceSum(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
Definition history.c:652
void SCIPhistoryIncGMIeffSum(SCIP_HISTORY *history, SCIP_Real gmieff)
Definition history.c:759
internal methods for branching and inference history
SCIP_Longint SCIPcliquetableGetNEntries(SCIP_CLIQUETABLE *cliquetable)
Definition implics.c:3536
methods for implications, variable bounds, and cliques
memory allocation routines
#define BMSclearMemoryArray(ptr, num)
Definition memory.h:130
void SCIPmessageFPrintInfo(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *formatstr,...)
Definition message.c:618
int SCIPpricestoreGetNVars(SCIP_PRICESTORE *pricestore)
Definition pricestore.c:609
int SCIPpricestoreGetNVarsApplied(SCIP_PRICESTORE *pricestore)
Definition pricestore.c:671
SCIP_Real SCIPpricestoreGetProbPricingTime(SCIP_PRICESTORE *pricestore)
Definition pricestore.c:631
int SCIPpricestoreGetNVarsFound(SCIP_PRICESTORE *pricestore)
Definition pricestore.c:661
int SCIPpricestoreGetNProbvarsFound(SCIP_PRICESTORE *pricestore)
Definition pricestore.c:651
int SCIPpricestoreGetNProbPricings(SCIP_PRICESTORE *pricestore)
Definition pricestore.c:641
internal methods for storing priced variables
SCIP_Bool SCIPprimalUpperboundIsSol(SCIP_PRIMAL *primal, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob)
Definition primal.c:578
SCIP_RETCODE SCIPprimalSetCutoffbound(SCIP_PRIMAL *primal, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_Real cutoffbound, SCIP_Bool useforobjlimit)
Definition primal.c:307
internal methods for collecting primal CIP solutions and primal informations
void SCIPprobPrintStatistics(SCIP_PROB *prob, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
Definition prob.c:2261
SCIP_Real SCIPprobExternObjval(SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_SET *set, SCIP_Real objval)
Definition prob.c:2157
SCIP_Real SCIPprobInternObjval(SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_SET *set, SCIP_Real objval)
Definition prob.c:2179
internal methods for storing and manipulating the main problem
public methods for Benders' decomposition
public methods for Benders' decomposition cuts
public methods for branching rules
public methods for tree compressions
public methods for managing constraints
public methods for storing cuts in a cut pool
public methods for cut selectors
public functions to work with algebraic expressions
public methods for primal heuristics
public methods for branching and inference history structure
public methods for message output
#define SCIPerrorMessage
Definition pub_message.h:64
public data structures and miscellaneous methods
methods for sorting joint arrays of various types
public methods for NLP solver interfaces
public methods for presolvers
public methods for variable pricers
public methods for propagators
public methods for input file readers
public methods for relaxation handlers
public methods for reoptimization
int SCIPreoptGetNTotalPrunedNodes(SCIP_REOPT *reopt)
Definition reopt.c:4993
int SCIPreoptGetNTotalFeasNodes(SCIP_REOPT *reopt)
Definition reopt.c:4973
int SCIPreoptGetFirstRestarts(SCIP_REOPT *reopt)
Definition reopt.c:4943
int SCIPreoptGetNTotalRestartsLocal(SCIP_REOPT *reopt)
Definition reopt.c:4933
int SCIPreoptGetLastRestarts(SCIP_REOPT *reopt)
Definition reopt.c:4953
int SCIPreoptGetNTotalCutoffReoptnodes(SCIP_REOPT *reopt)
Definition reopt.c:5013
int SCIPreoptGetNTotalInfNodes(SCIP_REOPT *reopt)
Definition reopt.c:5033
int SCIPreoptGetNRestartsGlobal(SCIP_REOPT *reopt)
Definition reopt.c:4913
public methods for separators
public methods for primal CIP solutions
public methods for displaying statistic tables
public methods for problem variables
SCIP_RETCODE SCIPreaderWrite(SCIP_READER *reader, SCIP_PROB *prob, SCIP_SET *set, FILE *file, const char *extension, SCIP_Bool genericnames, SCIP_RESULT *result)
Definition reader.c:270
internal methods for input file readers
SCIP_Real SCIPreoptGetSavingtime(SCIP_REOPT *reopt)
Definition reopt.c:7598
data structures and methods for collecting reoptimization information
public methods for Benders decomposition
general public methods
public methods for memory management
public methods for message handling
public methods for nonlinear relaxation
public methods for numerical tolerances
public methods for solutions
static SCIP_RETCODE printProblem(SCIP *scip, SCIP_PROB *prob, FILE *file, const char *extension, SCIP_Bool genericnames)
public methods for querying solving statistics
public methods for statistics table plugins
public methods for timing
public methods for SCIP variables
int SCIPsepastoreGetNCutsFoundRound(SCIP_SEPASTORE *sepastore)
Definition sepastore.c:1190
int SCIPsepastoreGetNCutsApplied(SCIP_SEPASTORE *sepastore)
Definition sepastore.c:1200
int SCIPsepastoreGetNCutsAdded(SCIP_SEPASTORE *sepastore)
Definition sepastore.c:1160
internal methods for storing separated cuts
void SCIPsetSortCutsels(SCIP_SET *set)
Definition set.c:4332
void SCIPsetSortBranchrulesName(SCIP_SET *set)
Definition set.c:4908
void SCIPsetSortPresolsName(SCIP_SET *set)
Definition set.c:4125
void SCIPsetSortRelaxsName(SCIP_SET *set)
Definition set.c:4199
void SCIPsetSortPropsName(SCIP_SET *set)
Definition set.c:4423
SCIP_Real SCIPsetEpsilon(SCIP_SET *set)
Definition set.c:6074
void SCIPsetSortComprsName(SCIP_SET *set)
Definition set.c:4702
void SCIPsetSortPricersName(SCIP_SET *set)
Definition set.c:3746
SCIP_Real SCIPsetInfinity(SCIP_SET *set)
Definition set.c:6052
SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)
Definition set.c:6187
void SCIPsetSortHeursName(SCIP_SET *set)
Definition set.c:4628
void SCIPsetSortSepasName(SCIP_SET *set)
Definition set.c:4273
internal methods for global SCIP settings
SCIP_Real SCIPsolGetObj(SCIP_SOL *sol, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob)
Definition sol.c:1571
internal methods for storing primal CIP solutions
void SCIPstatUpdatePrimalDualIntegrals(SCIP_STAT *stat, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_Real upperbound, SCIP_Real lowerbound)
Definition stat.c:459
SCIP_Real SCIPstatGetPrimalReferenceIntegral(SCIP_STAT *stat, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_Bool update)
Definition stat.c:573
SCIP_Real SCIPstatGetDualReferenceIntegral(SCIP_STAT *stat, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_Bool update)
Definition stat.c:552
SCIP_Real SCIPstatGetPrimalDualIntegral(SCIP_STAT *stat, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_Bool update)
Definition stat.c:594
internal methods for problem statistics
datastructures for block memory pools and memory buffers
datastructures for collecting primal CIP solutions and primal informations
datastructures for storing and manipulating the main problem
SCIP main data structure.
datastructures for global SCIP settings
datastructures for problem statistics
int SCIPsyncstoreGetWinner(SCIP_SYNCSTORE *syncstore)
Definition syncstore.c:527
SCIP_Bool SCIPsyncstoreIsInitialized(SCIP_SYNCSTORE *syncstore)
Definition syncstore.c:791
the function declarations for the synchronization store
SCIP_RETCODE SCIPtableOutput(SCIP_TABLE *table, SCIP_SET *set, FILE *file)
Definition table.c:272
internal methods for displaying statistics tables
SCIP_Real SCIPtreeGetAvgLowerbound(SCIP_TREE *tree, SCIP_Real cutoffbound)
Definition tree.c:7393
SCIP_Real SCIPtreeGetLowerbound(SCIP_TREE *tree, SCIP_SET *set)
Definition tree.c:7303
int SCIPtreeGetNNodes(SCIP_TREE *tree)
Definition tree.c:8305
internal methods for branch and bound tree
enum SCIP_DiveContext SCIP_DIVECONTEXT
Definition type_heur.h:73
@ SCIP_DIVECONTEXT_SINGLE
Definition type_heur.h:69
@ SCIP_DIVECONTEXT_ADAPTIVE
Definition type_heur.h:70
@ SCIP_DIVECONTEXT_SCHEDULER
Definition type_heur.h:71
@ SCIP_BRANCHDIR_DOWNWARDS
@ SCIP_BRANCHDIR_UPWARDS
enum SCIP_BranchDir SCIP_BRANCHDIR
enum SCIP_VerbLevel SCIP_VERBLEVEL
#define SCIP_DECL_SORTPTRCOMP(x)
Definition type_misc.h:188
enum SCIP_NlpSolStat SCIP_NLPSOLSTAT
Definition type_nlpi.h:168
@ SCIP_NLPTERMSTAT_OKAY
Definition type_nlpi.h:173
@ SCIP_NLPTERMSTAT_OTHER
Definition type_nlpi.h:182
@ SCIP_NLPSOLSTAT_GLOBOPT
Definition type_nlpi.h:160
@ SCIP_NLPSOLSTAT_UNKNOWN
Definition type_nlpi.h:166
enum SCIP_NlpTermStat SCIP_NLPTERMSTAT
Definition type_nlpi.h:194
@ SCIP_DIDNOTRUN
Definition type_result.h:42
@ SCIP_SUCCESS
Definition type_result.h:58
enum SCIP_Result SCIP_RESULT
Definition type_result.h:61
@ SCIP_READERROR
@ SCIP_PLUGINNOTFOUND
@ SCIP_WRITEERROR
@ SCIP_INVALIDCALL
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_STAGE_PROBLEM
Definition type_set.h:45
@ SCIP_STAGE_INITPRESOLVE
Definition type_set.h:48
@ SCIP_STAGE_SOLVED
Definition type_set.h:54
@ SCIP_STAGE_PRESOLVING
Definition type_set.h:49
@ SCIP_STAGE_TRANSFORMED
Definition type_set.h:47
@ SCIP_STAGE_INITSOLVE
Definition type_set.h:52
@ SCIP_STAGE_EXITPRESOLVE
Definition type_set.h:50
@ SCIP_STAGE_INIT
Definition type_set.h:44
@ SCIP_STAGE_SOLVING
Definition type_set.h:53
@ SCIP_STAGE_PRESOLVED
Definition type_set.h:51
@ SCIP_STATUS_UNBOUNDED
Definition type_stat.h:63
@ SCIP_STATUS_INFORUNBD
Definition type_stat.h:64
@ SCIP_STATUS_INFEASIBLE
Definition type_stat.h:62
@ SCIP_LOCKTYPE_MODEL
Definition type_var.h:97
SCIP_Real SCIPvarGetPseudocost(SCIP_VAR *var, SCIP_STAT *stat, SCIP_Real solvaldelta)
Definition var.c:14477
SCIP_Real SCIPvarGetPseudocostCount(SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition var.c:14573
SCIP_Real SCIPvarGetPseudocostVariance(SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun)
Definition var.c:14692
SCIP_Real SCIPvarGetAvgCutoffs(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition var.c:16265
SCIP_Real SCIPvarGetAvgInferences(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
Definition var.c:16067
internal methods for problem variables