Scippy

SCIP

Solving Constraint Integer Programs

disp_default.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 disp_default.c
26 * @ingroup DEFPLUGINS_DISP
27 * @brief default display columns
28 * @author Tobias Achterberg
29 */
30
31/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
32
33#include "lpi/lpi.h"
34#include "lpi/type_lpi.h"
35#include "scip/concurrent.h"
36#include "scip/disp_default.h"
37#include "scip/pub_disp.h"
38#include "scip/pub_heur.h"
39#include "scip/pub_message.h"
40#include "scip/pub_relax.h"
41#include "scip/pub_sol.h"
42#include "scip/scip_branch.h"
44#include "scip/scip_cut.h"
45#include "scip/scip_disp.h"
46#include "scip/scip_general.h"
47#include "scip/scip_lp.h"
48#include "scip/scip_mem.h"
49#include "scip/scip_message.h"
50#include "scip/scip_numerics.h"
51#include "scip/scip_prob.h"
52#include "scip/scip_sol.h"
54#include "scip/scip_timing.h"
55#include "scip/scip_tree.h"
56#include "scip/syncstore.h"
57#include <string.h>
58
59#define DISP_NAME_SOLFOUND "solfound"
60#define DISP_DESC_SOLFOUND "letter that indicates the heuristic which found the solution"
61#define DISP_HEAD_SOLFOUND " "
62#define DISP_WIDT_SOLFOUND 1
63#define DISP_PRIO_SOLFOUND 80000
64#define DISP_POSI_SOLFOUND 0
65#define DISP_STRI_SOLFOUND FALSE
66
67#define DISP_NAME_CONCSOLFOUND "concsolfound"
68#define DISP_DESC_CONCSOLFOUND "indicator that a new solution was found in concurrent solve"
69#define DISP_HEAD_CONCSOLFOUND " "
70#define DISP_WIDT_CONCSOLFOUND 1
71#define DISP_PRIO_CONCSOLFOUND 80000
72#define DISP_POSI_CONCSOLFOUND 0
73#define DISP_STRI_CONCSOLFOUND FALSE
74
75#define DISP_NAME_TIME "time"
76#define DISP_DESC_TIME "total solution time"
77#define DISP_HEAD_TIME "time"
78#define DISP_WIDT_TIME 5
79#define DISP_PRIO_TIME 4000
80#define DISP_POSI_TIME 50
81#define DISP_STRI_TIME TRUE
82
83#define DISP_NAME_NNODES "nnodes"
84#define DISP_DESC_NNODES "number of processed nodes"
85#define DISP_HEAD_NNODES "node"
86#define DISP_WIDT_NNODES 7
87#define DISP_PRIO_NNODES 100000
88#define DISP_POSI_NNODES 100
89#define DISP_STRI_NNODES TRUE
90
91#define DISP_NAME_NODESLEFT "nodesleft"
92#define DISP_DESC_NODESLEFT "number of unprocessed nodes"
93#define DISP_HEAD_NODESLEFT "left"
94#define DISP_WIDT_NODESLEFT 7
95#define DISP_PRIO_NODESLEFT 90000
96#define DISP_POSI_NODESLEFT 200
97#define DISP_STRI_NODESLEFT TRUE
98
99
100#define DISP_NAME_LPITERATIONS "lpiterations"
101#define DISP_DESC_LPITERATIONS "number of simplex iterations"
102#define DISP_HEAD_LPITERATIONS "LP iter"
103#define DISP_WIDT_LPITERATIONS 7
104#define DISP_PRIO_LPITERATIONS 30000
105#define DISP_POSI_LPITERATIONS 1000
106#define DISP_STRI_LPITERATIONS TRUE
107
108#define DISP_NAME_LPAVGITERS "lpavgiterations"
109#define DISP_DESC_LPAVGITERS "average number of LP iterations since the last output line"
110#define DISP_HEAD_LPAVGITERS "LP it/n"
111#define DISP_WIDT_LPAVGITERS 7
112#define DISP_PRIO_LPAVGITERS 25000
113#define DISP_POSI_LPAVGITERS 1400
114#define DISP_STRI_LPAVGITERS TRUE
115
116#define DISP_NAME_LPCOND "lpcond"
117#define DISP_DESC_LPCOND "estimate on condition number of LP solution"
118#define DISP_HEAD_LPCOND "LP cond"
119#define DISP_WIDT_LPCOND 7
120#define DISP_PRIO_LPCOND 0
121#define DISP_POSI_LPCOND 1450
122#define DISP_STRI_LPCOND TRUE
123
124#define DISP_NAME_MEMUSED "memused"
125#define DISP_DESC_MEMUSED "total number of bytes used in block memory"
126#define DISP_HEAD_MEMUSED "umem"
127#define DISP_WIDT_MEMUSED 5
128#define DISP_PRIO_MEMUSED 0
129#define DISP_POSI_MEMUSED 1500
130#define DISP_STRI_MEMUSED TRUE
131
132#define DISP_NAME_CONCMEMUSED "concmemused"
133#define DISP_DESC_CONCMEMUSED "total number of bytes used in block memory"
134#define DISP_HEAD_CONCMEMUSED "mem"
135#define DISP_WIDT_CONCMEMUSED 5
136#define DISP_PRIO_CONCMEMUSED 20000
137#define DISP_POSI_CONCMEMUSED 1500
138#define DISP_STRI_CONCMEMUSED TRUE
139
140#define DISP_NAME_MEMTOTAL "memtotal"
141#define DISP_DESC_MEMTOTAL "total number of bytes in block memory or the creator name when a new incumbent solution was found"
142#define DISP_HEAD_MEMTOTAL "mem/heur"
143#define DISP_WIDT_MEMTOTAL 8 /* the width of the column is 8, since we print 8 characters for new incumbents */
144#define DISP_WIDT_MEMONLY 5 /* for memory output, we only use 5 characters because this is easier to decipher */
145#define DISP_PRIO_MEMTOTAL 20000
146#define DISP_POSI_MEMTOTAL 1500
147#define DISP_STRI_MEMTOTAL TRUE
148
149#define DISP_NAME_DEPTH "depth"
150#define DISP_DESC_DEPTH "depth of current node"
151#define DISP_HEAD_DEPTH "depth"
152#define DISP_WIDT_DEPTH 5
153#define DISP_PRIO_DEPTH 500
154#define DISP_POSI_DEPTH 2000
155#define DISP_STRI_DEPTH TRUE
156
157#define DISP_NAME_MAXDEPTH "maxdepth"
158#define DISP_DESC_MAXDEPTH "maximal depth of all processed nodes"
159#define DISP_HEAD_MAXDEPTH "mdpt"
160#define DISP_WIDT_MAXDEPTH 5
161#define DISP_PRIO_MAXDEPTH 5000
162#define DISP_POSI_MAXDEPTH 2100
163#define DISP_STRI_MAXDEPTH TRUE
164
165#define DISP_NAME_PLUNGEDEPTH "plungedepth"
166#define DISP_DESC_PLUNGEDEPTH "current plunging depth"
167#define DISP_HEAD_PLUNGEDEPTH "pdpt"
168#define DISP_WIDT_PLUNGEDEPTH 5
169#define DISP_PRIO_PLUNGEDEPTH 10
170#define DISP_POSI_PLUNGEDEPTH 2200
171#define DISP_STRI_PLUNGEDEPTH TRUE
172
173#define DISP_NAME_NFRAC "nfrac"
174#define DISP_DESC_NFRAC "number of fractional variables in the current solution"
175#define DISP_HEAD_NFRAC "frac"
176#define DISP_WIDT_NFRAC 5
177#define DISP_PRIO_NFRAC 700
178#define DISP_POSI_NFRAC 2500
179#define DISP_STRI_NFRAC TRUE
180
181#define DISP_NAME_NEXTERNCANDS "nexternbranchcands"
182#define DISP_DESC_NEXTERNCANDS "number of extern branching variables in the current node"
183#define DISP_HEAD_NEXTERNCANDS "extbr"
184#define DISP_WIDT_NEXTERNCANDS 5
185#define DISP_PRIO_NEXTERNCANDS 650
186#define DISP_POSI_NEXTERNCANDS 2600
187#define DISP_STRI_NEXTERNCANDS TRUE
188
189#define DISP_NAME_VARS "vars"
190#define DISP_DESC_VARS "number of variables in the problem"
191#define DISP_HEAD_VARS "vars"
192#define DISP_WIDT_VARS 5
193#define DISP_PRIO_VARS 3000
194#define DISP_POSI_VARS 3000
195#define DISP_STRI_VARS TRUE
196
197#define DISP_NAME_CONSS "conss"
198#define DISP_DESC_CONSS "number of globally valid constraints in the problem"
199#define DISP_HEAD_CONSS "cons"
200#define DISP_WIDT_CONSS 5
201#define DISP_PRIO_CONSS 3100
202#define DISP_POSI_CONSS 3100
203#define DISP_STRI_CONSS TRUE
204
205#define DISP_NAME_CURCONSS "curconss"
206#define DISP_DESC_CURCONSS "number of enabled constraints in current node"
207#define DISP_HEAD_CURCONSS "ccons"
208#define DISP_WIDT_CURCONSS 5
209#define DISP_PRIO_CURCONSS 600
210#define DISP_POSI_CURCONSS 3200
211#define DISP_STRI_CURCONSS TRUE
212
213#define DISP_NAME_CURCOLS "curcols"
214#define DISP_DESC_CURCOLS "number of LP columns in current node"
215#define DISP_HEAD_CURCOLS "cols"
216#define DISP_WIDT_CURCOLS 5
217#define DISP_PRIO_CURCOLS 800
218#define DISP_POSI_CURCOLS 3300
219#define DISP_STRI_CURCOLS TRUE
220
221#define DISP_NAME_CURROWS "currows"
222#define DISP_DESC_CURROWS "number of LP rows in current node"
223#define DISP_HEAD_CURROWS "rows"
224#define DISP_WIDT_CURROWS 5
225#define DISP_PRIO_CURROWS 900
226#define DISP_POSI_CURROWS 3400
227#define DISP_STRI_CURROWS TRUE
228
229#define DISP_NAME_CUTS "cuts"
230#define DISP_DESC_CUTS "total number of cuts applied to the LPs"
231#define DISP_HEAD_CUTS "cuts"
232#define DISP_WIDT_CUTS 5
233#define DISP_PRIO_CUTS 2100
234#define DISP_POSI_CUTS 3500
235#define DISP_STRI_CUTS TRUE
236
237#define DISP_NAME_SEPAROUNDS "separounds"
238#define DISP_DESC_SEPAROUNDS "number of separation rounds performed at the current node"
239#define DISP_HEAD_SEPAROUNDS "sepa"
240#define DISP_WIDT_SEPAROUNDS 4
241#define DISP_PRIO_SEPAROUNDS 100
242#define DISP_POSI_SEPAROUNDS 3600
243#define DISP_STRI_SEPAROUNDS TRUE
244
245#define DISP_NAME_POOLSIZE "poolsize"
246#define DISP_DESC_POOLSIZE "number of LP rows in the cut pool"
247#define DISP_HEAD_POOLSIZE "pool"
248#define DISP_WIDT_POOLSIZE 5
249#define DISP_PRIO_POOLSIZE 50
250#define DISP_POSI_POOLSIZE 3700
251#define DISP_STRI_POOLSIZE TRUE
252
253#define DISP_NAME_CONFLICTS "conflicts"
254#define DISP_DESC_CONFLICTS "total number of conflicts found in conflict analysis"
255#define DISP_HEAD_CONFLICTS "confs"
256#define DISP_WIDT_CONFLICTS 5
257#define DISP_PRIO_CONFLICTS 2000
258#define DISP_POSI_CONFLICTS 4000
259#define DISP_STRI_CONFLICTS TRUE
260
261#define DISP_NAME_STRONGBRANCHS "strongbranchs"
262#define DISP_DESC_STRONGBRANCHS "total number of strong branching calls"
263#define DISP_HEAD_STRONGBRANCHS "strbr"
264#define DISP_WIDT_STRONGBRANCHS 5
265#define DISP_PRIO_STRONGBRANCHS 1000
266#define DISP_POSI_STRONGBRANCHS 5000
267#define DISP_STRI_STRONGBRANCHS TRUE
268
269#define DISP_NAME_PSEUDOOBJ "pseudoobj"
270#define DISP_DESC_PSEUDOOBJ "current pseudo objective value"
271#define DISP_HEAD_PSEUDOOBJ "pseudoobj"
272#define DISP_WIDT_PSEUDOOBJ 14
273#define DISP_PRIO_PSEUDOOBJ 300
274#define DISP_POSI_PSEUDOOBJ 6000
275#define DISP_STRI_PSEUDOOBJ TRUE
276
277#define DISP_NAME_LPOBJ "lpobj"
278#define DISP_DESC_LPOBJ "current LP objective value"
279#define DISP_HEAD_LPOBJ "lpobj"
280#define DISP_WIDT_LPOBJ 14
281#define DISP_PRIO_LPOBJ 300
282#define DISP_POSI_LPOBJ 6500
283#define DISP_STRI_LPOBJ TRUE
284
285#define DISP_NAME_CURDUALBOUND "curdualbound"
286#define DISP_DESC_CURDUALBOUND "dual bound of current node"
287#define DISP_HEAD_CURDUALBOUND "curdualbound"
288#define DISP_WIDT_CURDUALBOUND 14
289#define DISP_PRIO_CURDUALBOUND 400
290#define DISP_POSI_CURDUALBOUND 7000
291#define DISP_STRI_CURDUALBOUND TRUE
292
293#define DISP_NAME_ESTIMATE "estimate"
294#define DISP_DESC_ESTIMATE "estimated value of feasible solution in current node"
295#define DISP_HEAD_ESTIMATE "estimate"
296#define DISP_WIDT_ESTIMATE 14
297#define DISP_PRIO_ESTIMATE 200
298#define DISP_POSI_ESTIMATE 7500
299#define DISP_STRI_ESTIMATE TRUE
300
301#define DISP_NAME_AVGDUALBOUND "avgdualbound"
302#define DISP_DESC_AVGDUALBOUND "average dual bound of all unprocessed nodes"
303#define DISP_HEAD_AVGDUALBOUND "avgdualbound"
304#define DISP_WIDT_AVGDUALBOUND 14
305#define DISP_PRIO_AVGDUALBOUND 40
306#define DISP_POSI_AVGDUALBOUND 8000
307#define DISP_STRI_AVGDUALBOUND TRUE
308
309#define DISP_NAME_DUALBOUND "dualbound"
310#define DISP_DESC_DUALBOUND "current global dual bound"
311#define DISP_HEAD_DUALBOUND "dualbound"
312#define DISP_WIDT_DUALBOUND 14
313#define DISP_PRIO_DUALBOUND 70000
314#define DISP_POSI_DUALBOUND 9000
315#define DISP_STRI_DUALBOUND TRUE
316
317#define DISP_NAME_CONCDUALBOUND "concdualbound"
318#define DISP_DESC_CONCDUALBOUND "current global dual bound in concurrent solve"
319#define DISP_HEAD_CONCDUALBOUND "dualbound"
320#define DISP_WIDT_CONCDUALBOUND 14
321#define DISP_PRIO_CONCDUALBOUND 70000
322#define DISP_POSI_CONCDUALBOUND 9000
323#define DISP_STRI_CONCDUALBOUND TRUE
324
325#define DISP_NAME_PRIMALBOUND "primalbound"
326#define DISP_DESC_PRIMALBOUND "current primal bound"
327#define DISP_HEAD_PRIMALBOUND "primalbound"
328#define DISP_WIDT_PRIMALBOUND 14
329#define DISP_PRIO_PRIMALBOUND 80000
330#define DISP_POSI_PRIMALBOUND 10000
331#define DISP_STRI_PRIMALBOUND TRUE
332
333#define DISP_NAME_CONCPRIMALBOUND "concprimalbound"
334#define DISP_DESC_CONCPRIMALBOUND "current primal bound in concurrent solve"
335#define DISP_HEAD_CONCPRIMALBOUND "primalbound"
336#define DISP_WIDT_CONCPRIMALBOUND 14
337#define DISP_PRIO_CONCPRIMALBOUND 80000
338#define DISP_POSI_CONCPRIMALBOUND 10000
339#define DISP_STRI_CONCPRIMALBOUND TRUE
340
341#define DISP_NAME_CUTOFFBOUND "cutoffbound"
342#define DISP_DESC_CUTOFFBOUND "current cutoff bound"
343#define DISP_HEAD_CUTOFFBOUND "cutoffbound"
344#define DISP_WIDT_CUTOFFBOUND 14
345#define DISP_PRIO_CUTOFFBOUND 10
346#define DISP_POSI_CUTOFFBOUND 10100
347#define DISP_STRI_CUTOFFBOUND TRUE
348
349#define DISP_NAME_GAP "gap"
350#define DISP_DESC_GAP "current (relative) gap using |primal-dual|/MIN(|dual|,|primal|)"
351#define DISP_HEAD_GAP "gap"
352#define DISP_WIDT_GAP 8
353#define DISP_PRIO_GAP 60000
354#define DISP_POSI_GAP 20000
355#define DISP_STRI_GAP TRUE
356
357#define DISP_NAME_CONCGAP "concgap"
358#define DISP_DESC_CONCGAP "current (relative) gap in concurrent solve using |primal-dual|/MIN(|dual|,|primal|)"
359#define DISP_HEAD_CONCGAP "gap"
360#define DISP_WIDT_CONCGAP 8
361#define DISP_PRIO_CONCGAP 60000
362#define DISP_POSI_CONCGAP 20000
363#define DISP_STRI_CONCGAP TRUE
364
365#define DISP_NAME_PRIMALGAP "primalgap"
366#define DISP_DESC_PRIMALGAP "current (relative) gap using |primal-dual|/|primal|"
367#define DISP_HEAD_PRIMALGAP "primgap"
368#define DISP_WIDT_PRIMALGAP 8
369#define DISP_PRIO_PRIMALGAP 20000
370#define DISP_POSI_PRIMALGAP 21000
371#define DISP_STRI_PRIMALGAP TRUE
372
373#define DISP_NAME_NSOLS "nsols"
374#define DISP_DESC_NSOLS "current number of solutions found"
375#define DISP_HEAD_NSOLS "nsols"
376#define DISP_WIDT_NSOLS 5
377#define DISP_PRIO_NSOLS 0
378#define DISP_POSI_NSOLS 30000
379#define DISP_STRI_NSOLS TRUE
380
381/* display for the number of leaves passing the objective limit */
382#define DISP_NAME_NOBJLEAVES "nobjleaves"
383#define DISP_DESC_NOBJLEAVES "current number of encountered objective limit leaves"
384#define DISP_HEAD_NOBJLEAVES "objleav"
385#define DISP_WIDT_NOBJLEAVES 7
386#define DISP_PRIO_NOBJLEAVES 0
387#define DISP_POSI_NOBJLEAVES 31000
388#define DISP_STRI_NOBJLEAVES TRUE
389
390
391/* display for number of encountered infeasible leaf nodes */
392#define DISP_NAME_NINFEASLEAVES "ninfeasleaves"
393#define DISP_DESC_NINFEASLEAVES "number of encountered infeasible leaves"
394#define DISP_HEAD_NINFEASLEAVES "infleav"
395#define DISP_WIDT_NINFEASLEAVES 7
396#define DISP_PRIO_NINFEASLEAVES 0
397#define DISP_POSI_NINFEASLEAVES 32000
398#define DISP_STRI_NINFEASLEAVES TRUE
399
400/*
401 * Callback methods
402 */
403
404/** copy method for display plugins (called when SCIP copies plugins) */
405static
406SCIP_DECL_DISPCOPY(dispCopyDefault)
407{ /*lint --e{715}*/
408 assert(scip != NULL);
409 assert(disp != NULL);
410
411 /* call inclusion method of dialog (unless it has already been included by the copy call of the first default column) */
412 if( SCIPfindDisp(scip, SCIPdispGetName(disp)) == NULL )
413 {
415 }
416
417 return SCIP_OKAY;
418}
419
420/** solving process initialization method of display column (called when branch and bound process is about to begin) */
421static
422SCIP_DECL_DISPINITSOL(SCIPdispInitsolSolFound)
423{ /*lint --e{715}*/
424 assert(disp != NULL);
425 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_SOLFOUND) == 0
426 || strcmp(SCIPdispGetName(disp), DISP_NAME_MEMTOTAL) == 0);
427 assert(scip != NULL);
428
430
431 return SCIP_OKAY;
432}
433
434/** returns TRUE if this solution should be displayed in the output */
435static
437 SCIP* scip, /**< SCIP data structure */
438 SCIP_SOL* sol /**< solution data structure, e.g., current incumbent solution */
439 )
440{
442}
443
444/** output method of display column to output file stream 'file' for character of best solution */
445static
446SCIP_DECL_DISPOUTPUT(SCIPdispOutputSolFound)
447{ /*lint --e{715}*/
448 SCIP_SOL* sol;
449 SCIP_DISPDATA* dispdata;
450
451 assert(disp != NULL);
452 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_SOLFOUND) == 0);
453 assert(scip != NULL);
454
455 sol = SCIPgetBestSol(scip);
456 if( sol == NULL )
457 SCIPdispSetData(disp, NULL);
458
459 dispdata = SCIPdispGetData(disp);
460 if( sol != (SCIP_SOL*)dispdata && isDisplaySol(scip, sol) )
461 {
462 SCIP_HEUR* heur;
463 char c;
464
465 heur = SCIPgetSolHeur(scip, sol);
466
467 if( heur == NULL )
468 {
469 if( SCIPsolIsOriginal(sol) )
470 c = '#';
471 else
472 c = '*';
473 }
474 else
475 c = SCIPheurGetDispchar(heur);
476
477 SCIPinfoMessage(scip, file, "%c", c);
478
479 SCIPdispSetData(disp, (SCIP_DISPDATA*)sol);
480 }
481 else
482 SCIPinfoMessage(scip, file, " ");
483
484 return SCIP_OKAY;
485}
486
487/** solving process initialization method of display column (called when branch and bound process is about to begin) */
488static
489SCIP_DECL_DISPINITSOL(SCIPdispInitsolConcSolFound)
490{ /*lint --e{715}*/
491 SCIP_Real* bestupper;
492
493 assert(disp != NULL);
494 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_CONCSOLFOUND) == 0);
495 assert(scip != NULL);
496
497 SCIP_CALL( SCIPallocBlockMemory(scip, &bestupper) );
498 *bestupper = SCIPinfinity(scip);
499
500 SCIPdispSetData(disp, (SCIP_DISPDATA*) bestupper);
501
502 return SCIP_OKAY;
503}
504
505/** solving process initialization method of display column (called when branch and bound process is about to begin) */
506static
507SCIP_DECL_DISPINITSOL(SCIPdispExitsolConcSolFound)
508{ /*lint --e{715}*/
509 SCIP_Real* bestupper;
510
511 assert(disp != NULL);
512 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_CONCSOLFOUND) == 0);
513 assert(scip != NULL);
514
515 bestupper = (SCIP_Real*) SCIPdispGetData(disp);
516 SCIPfreeBlockMemory(scip, &bestupper);
517
518 SCIPdispSetData(disp, NULL);
519
520 return SCIP_OKAY;
521}
522
523/** output method of display column to output file stream 'file' for character of best solution */
524static
525SCIP_DECL_DISPOUTPUT(SCIPdispOutputConcSolFound)
526{ /*lint --e{715}*/
527 SCIP_Real* bestupper;
528 SCIP_Real newbestupper;
529 SCIP_SYNCSTORE* syncstore;
530
531 assert(disp != NULL);
532 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_CONCSOLFOUND) == 0);
533 assert(scip != NULL);
534
535 bestupper = (SCIP_Real*) SCIPdispGetData(disp);
536
537 syncstore = SCIPgetSyncstore(scip);
538 assert(syncstore != NULL);
539 newbestupper = SCIPsyncstoreGetLastUpperbound(syncstore);
540
541 if( SCIPsyncstoreGetLastNSols(syncstore) > 0 && SCIPisFeasLT(scip, newbestupper, *bestupper) )
542 {
543 SCIPinfoMessage(scip, file, "$");
544 *bestupper = newbestupper;
545 }
546 else
547 SCIPinfoMessage(scip, file, " ");
548
549 return SCIP_OKAY;
550}
551
552/** output method of display column to output file stream 'file' for solving time */
553static
554SCIP_DECL_DISPOUTPUT(SCIPdispOutputSolvingTime)
555{ /*lint --e{715}*/
556 assert(disp != NULL);
557 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_TIME) == 0);
558 assert(scip != NULL);
559
561
562 return SCIP_OKAY;
563}
564
565/** output method of display column to output file stream 'file' for number of nodes */
566static
567SCIP_DECL_DISPOUTPUT(SCIPdispOutputNNodes)
568{ /*lint --e{715}*/
569 assert(disp != NULL);
570 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_NNODES) == 0);
571 assert(scip != NULL);
572
574
575 return SCIP_OKAY;
576}
577
578/** output method of display column to output file stream 'file' for number of open nodes */
579static
580SCIP_DECL_DISPOUTPUT(SCIPdispOutputNNodesLeft)
581{ /*lint --e{715}*/
582 assert(disp != NULL);
583 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_NODESLEFT) == 0);
584 assert(scip != NULL);
585
587
588 return SCIP_OKAY;
589}
590
591/** output method of display column to output file stream 'file' */
592static
593SCIP_DECL_DISPOUTPUT(dispOutputNObjLeaves)
594{
595 assert(disp != NULL);
596 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_NOBJLEAVES) == 0);
597 assert(scip != NULL);
598
599 /* ouput number of leaves that hit the objective */
601
602 return SCIP_OKAY;
603}
604
605/** output method of display column to output file stream 'file' */
606static
607SCIP_DECL_DISPOUTPUT(dispOutputNInfeasLeaves)
608{
609 assert(disp != NULL);
610 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_NINFEASLEAVES) == 0);
611 assert(scip != NULL);
612
613 /* output number of encountered infeasible leaf nodes */
615
616 return SCIP_OKAY;
617}
618
619/** output method of display column to output file stream 'file' for number of LP iterations */
620static
621SCIP_DECL_DISPOUTPUT(SCIPdispOutputNLPIterations)
622{ /*lint --e{715}*/
623 assert(disp != NULL);
624 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_LPITERATIONS) == 0);
625 assert(scip != NULL);
626
628
629 return SCIP_OKAY;
630}
631
632/** output method of display column to output file stream 'file' for number of average LP iterations */
633static
634SCIP_DECL_DISPOUTPUT(SCIPdispOutputNLPAvgIters)
635{ /*lint --e{715}*/
636 assert(disp != NULL);
637 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_LPAVGITERS) == 0);
638 assert(scip != NULL);
639
640 /**@todo Currently we are using the total number of nodes to compute the average LP iterations number. The reason for
641 * that is, that for the LP iterations only the total number (over all runs) are stored in the statistics. It
642 * would be nicer if the statistic also stores the number of LP iterations for the current run similar to the
643 * nodes.
644 */
645
646 if( SCIPgetNNodes(scip) < 2 )
647 SCIPinfoMessage(scip, file, " - ");
648 else
649 SCIPinfoMessage(scip, file, "%6.1f ",
651
652 return SCIP_OKAY;
653}
654
655
656/** output method of display column to output file stream 'file' for estimate on LP condition */
657static
658SCIP_DECL_DISPOUTPUT(SCIPdispOutputLPCondition)
659{ /*lint --e{715}*/
660 SCIP_LPI* lpi;
661 SCIP_Real cond;
662
663 assert(disp != NULL);
664 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_LPCOND) == 0);
665 assert(scip != NULL);
666
667 /* note that after diving mode, the LPI may only have the basis information, but SCIPlpiWasSolved() can be false; in
668 * this case, we will (depending on the LP solver) probably not obtain the quality measure; one solution would be to
669 * store the results of SCIPlpiGetRealSolQuality() within the SCIP_LP after each LP solve; this would have the added
670 * advantage, that we reduce direct access to the LPI, but it sounds potentially expensive
671 */
672 SCIP_CALL( SCIPgetLPI(scip, &lpi) );
673 if( lpi == NULL )
674 {
675 SCIPinfoMessage(scip, file, " - ");
676 return SCIP_OKAY;
677 }
678
680
681 if( cond == SCIP_INVALID ) /*lint !e777*/
682 SCIPinfoMessage(scip, file, " n/a ");
683 else
684 SCIPinfoMessage(scip, file, "%.1e", cond);
685
686 return SCIP_OKAY;
687}
688
689/** output method of display column to output file stream 'file' for depth */
690static
691SCIP_DECL_DISPOUTPUT(SCIPdispOutputDepth)
692{ /*lint --e{715}*/
693 assert(disp != NULL);
694 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_DEPTH) == 0);
695 assert(scip != NULL);
696
698
699 return SCIP_OKAY;
700}
701
702/** output method of display column to output file stream 'file' for used memory */
703static
704SCIP_DECL_DISPOUTPUT(SCIPdispOutputMemUsed)
705{ /*lint --e{715}*/
706 assert(disp != NULL);
707 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_MEMUSED) == 0);
708 assert(scip != NULL);
709
711
712 return SCIP_OKAY;
713}
714
715/** output method of display column to output file stream 'file' for used memory */
716static
717SCIP_DECL_DISPOUTPUT(SCIPdispOutputConcMemUsed)
718{ /*lint --e{715}*/
719 SCIP_SYNCSTORE* syncstore;
720 assert(disp != NULL);
721 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_CONCMEMUSED) == 0);
722 assert(scip != NULL);
723
724 syncstore = SCIPgetSyncstore(scip);
725 assert(syncstore != NULL);
726
728
729 return SCIP_OKAY;
730}
731
732/** output method of display column to output file stream 'file' for allocated and used memory, or creator name after a
733 * new incumbent solution has been found
734 */
735static
736SCIP_DECL_DISPOUTPUT(SCIPdispOutputMemUsedTotal)
737{ /*lint --e{715}*/
738 SCIP_SOL* sol;
739 SCIP_DISPDATA* dispdata;
740
741 assert(disp != NULL);
742 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_MEMTOTAL) == 0);
743 assert(scip != NULL);
744
745 sol = SCIPgetBestSol(scip);
746 if( sol == NULL )
747 SCIPdispSetData(disp, NULL);
748
749 dispdata = SCIPdispGetData(disp);
750 /* display */
751 if( sol != (SCIP_SOL*)dispdata && isDisplaySol(scip, sol) )
752 {
753 SCIP_HEUR* heur;
754 SCIP_RELAX* relax;
755 char const* infostr;
756
757 switch( SCIPsolGetType(sol) )
758 {
760 infostr = "LP ";
761 break;
763 infostr = "strongbranch";
764 break;
766 infostr = "pseudosol";
767 break;
769 relax = SCIPsolGetRelax(sol);
770 infostr = relax != NULL ? SCIPrelaxGetName(relax) : "relaxation";
771 break;
773 heur = SCIPsolGetHeur(sol);
774 infostr = heur != NULL ? SCIPheurGetName(heur) : "heuristic";
775 break;
777 default:
778 infostr = "unknown";
779 break;
780 }
782
783 SCIPdispSetData(disp, (SCIP_DISPDATA*)sol);
784 }
785 else
786 {
787 /* for memory output, we only use 5 characters because this is easier to decipher */
788 assert(DISP_WIDT_MEMTOTAL-DISP_WIDT_MEMONLY>0); /*lint !e506*/
791 SCIPinfoMessage(scip, file, " ");
792 }
793
794 return SCIP_OKAY;
795}
796
797/** output method of display column to output file stream 'file' for maximal depth */
798static
799SCIP_DECL_DISPOUTPUT(SCIPdispOutputMaxDepth)
800{ /*lint --e{715}*/
801 assert(disp != NULL);
802 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_MAXDEPTH) == 0);
803 assert(scip != NULL);
804
806
807 return SCIP_OKAY;
808}
809
810/** output method of display column to output file stream 'file' for plunging depth */
811static
812SCIP_DECL_DISPOUTPUT(SCIPdispOutputPlungeDepth)
813{ /*lint --e{715}*/
814 assert(disp != NULL);
815 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_PLUNGEDEPTH) == 0);
816 assert(scip != NULL);
817
819
820 return SCIP_OKAY;
821}
822
823/** output method of display column to output file stream 'file' for number of LP branch candidates */
824static
825SCIP_DECL_DISPOUTPUT(SCIPdispOutputNFrac)
826{ /*lint --e{715}*/
827 assert(disp != NULL);
828 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_NFRAC) == 0);
829 assert(scip != NULL);
830
833 else
834 SCIPinfoMessage(scip, file, " - ");
835
836 return SCIP_OKAY;
837}
838
839/** output method of display column to output file stream 'file' for number of external branch candidates */
840static
841SCIP_DECL_DISPOUTPUT(SCIPdispOutputNExternCands)
842{ /*lint --e{715}*/
843 assert(disp != NULL);
844 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_NEXTERNCANDS) == 0);
845 assert(scip != NULL);
846
848
849 return SCIP_OKAY;
850}
851
852/** output method of display column to output file stream 'file' for number of variables */
853static
854SCIP_DECL_DISPOUTPUT(SCIPdispOutputNVars)
855{ /*lint --e{715}*/
856 assert(disp != NULL);
857 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_VARS) == 0);
858 assert(scip != NULL);
859
861
862 return SCIP_OKAY;
863}
864
865/** output method of display column to output file stream 'file' for number of constraints */
866static
867SCIP_DECL_DISPOUTPUT(SCIPdispOutputNConss)
868{ /*lint --e{715}*/
869 assert(disp != NULL);
870 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_CONSS) == 0);
871 assert(scip != NULL);
872
874
875 return SCIP_OKAY;
876}
877
878/** output method of display column to output file stream 'file' for number of enabled constraints */
879static
880SCIP_DECL_DISPOUTPUT(SCIPdispOutputNCurConss)
881{ /*lint --e{715}*/
882 assert(disp != NULL);
883 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_CURCONSS) == 0);
884 assert(scip != NULL);
885
887
888 return SCIP_OKAY;
889}
890
891/** output method of display column to output file stream 'file' for number of columns in the LP */
892static
893SCIP_DECL_DISPOUTPUT(SCIPdispOutputNCurCols)
894{ /*lint --e{715}*/
895 assert(disp != NULL);
896 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_CURCOLS) == 0);
897 assert(scip != NULL);
898
900
901 return SCIP_OKAY;
902}
903
904/** output method of display column to output file stream 'file' for number of rows in the LP */
905static
906SCIP_DECL_DISPOUTPUT(SCIPdispOutputNCurRows)
907{ /*lint --e{715}*/
908 assert(disp != NULL);
909 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_CURROWS) == 0);
910 assert(scip != NULL);
911
913
914 return SCIP_OKAY;
915}
916
917/** output method of display column to output file stream 'file' for number of applied cuts */
918static
919SCIP_DECL_DISPOUTPUT(SCIPdispOutputNAppliedCuts)
920{ /*lint --e{715}*/
921 assert(disp != NULL);
922 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_CUTS) == 0);
923 assert(scip != NULL);
924
926
927 return SCIP_OKAY;
928}
929
930/** output method of display column to output file stream 'file' for number of separation rounds */
931static
932SCIP_DECL_DISPOUTPUT(SCIPdispOutputNSepaRounds)
933{ /*lint --e{715}*/
934 assert(disp != NULL);
935 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_SEPAROUNDS) == 0);
936 assert(scip != NULL);
937
939
940 return SCIP_OKAY;
941}
942
943/** output method of display column to output file stream 'file' for number of current rows in the cut pool */
944static
945SCIP_DECL_DISPOUTPUT(SCIPdispOutputCutPoolSize)
946{ /*lint --e{715}*/
947 assert(disp != NULL);
948 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_POOLSIZE) == 0);
949 assert(scip != NULL);
950
952
953 return SCIP_OKAY;
954}
955
956/** output method of display column to output file stream 'file' for number of conflicts */
957static
958SCIP_DECL_DISPOUTPUT(SCIPdispOutputNConflicts)
959{ /*lint --e{715}*/
960 SCIP_Longint applied;
961
962 assert(disp != NULL);
963 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_CONFLICTS) == 0);
964 assert(scip != NULL);
965
968
969 return SCIP_OKAY;
970}
971
972/** output method of display column to output file stream 'file' for number of strong branchings */
973static
974SCIP_DECL_DISPOUTPUT(SCIPdispOutputNStrongbranchs)
975{ /*lint --e{715}*/
976 assert(disp != NULL);
977 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_STRONGBRANCHS) == 0);
978 assert(scip != NULL);
979
981
982 return SCIP_OKAY;
983}
984
985/** output method of display column to output file stream 'file' for pseudo objective value */
986static
987SCIP_DECL_DISPOUTPUT(SCIPdispOutputPseudoObjval)
988{ /*lint --e{715}*/
989 SCIP_Real pseudoobj;
990
991 assert(disp != NULL);
992 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_PSEUDOOBJ) == 0);
993 assert(scip != NULL);
994
995 pseudoobj = SCIPgetPseudoObjval(scip);
996
997 if( SCIPisInfinity(scip, -pseudoobj) )
998 SCIPinfoMessage(scip, file, " -- ");
999 else if( SCIPisInfinity(scip, pseudoobj) )
1000 SCIPinfoMessage(scip, file, " cutoff ");
1001 else
1002 SCIPinfoMessage(scip, file, "%13.6e ", pseudoobj);
1003
1004 return SCIP_OKAY;
1005}
1006
1007/** output method of display column to output file stream 'file' for LP objective value */
1008static
1009SCIP_DECL_DISPOUTPUT(SCIPdispOutputLPObjval)
1010{ /*lint --e{715}*/
1011 SCIP_Real lpobj;
1012
1013 assert(disp != NULL);
1014 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_LPOBJ) == 0);
1015 assert(scip != NULL);
1016
1018 SCIPinfoMessage(scip, file, " -- ");
1019 else
1020 {
1021 lpobj = SCIPgetLPObjval(scip);
1022
1023 if( SCIPisInfinity(scip, -lpobj) )
1024 SCIPinfoMessage(scip, file, " -- ");
1025 else if( SCIPisInfinity(scip, lpobj) )
1026 SCIPinfoMessage(scip, file, " cutoff ");
1027 else
1028 SCIPinfoMessage(scip, file, "%13.6e ", lpobj);
1029 }
1030
1031 return SCIP_OKAY;
1032}
1033
1034/** output method of display column to output file stream 'file' for the current dualbound */
1035static
1036SCIP_DECL_DISPOUTPUT(SCIPdispOutputCurDualbound)
1037{ /*lint --e{715}*/
1038 SCIP_Real curdualbound;
1039
1040 assert(disp != NULL);
1041 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_CURDUALBOUND) == 0);
1042 assert(scip != NULL);
1043
1044 curdualbound = SCIPgetLocalDualbound(scip);
1045
1046 if( SCIPisInfinity(scip, (SCIP_Real) SCIPgetObjsense(scip) * curdualbound ) )
1047 SCIPinfoMessage(scip, file, " cutoff ");
1048 else if( SCIPisInfinity(scip, -1.0 * (SCIP_Real) SCIPgetObjsense(scip) * curdualbound ) )
1049 SCIPinfoMessage(scip, file, " -- ");
1050 else
1051 SCIPinfoMessage(scip, file, "%13.6e ", curdualbound);
1052
1053 return SCIP_OKAY;
1054}
1055
1056/** output method of display column to output file stream 'file' for estimate of best primal solution w.r.t. original
1057 * problem contained in current subtree */
1058static
1059SCIP_DECL_DISPOUTPUT(SCIPdispOutputLocalOrigEstimate)
1060{ /*lint --e{715}*/
1061 SCIP_Real estimate;
1062
1063 assert(disp != NULL);
1064 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_ESTIMATE) == 0);
1065 assert(scip != NULL);
1066
1067 estimate = SCIPgetLocalOrigEstimate(scip);
1068 if( SCIPisInfinity(scip, REALABS(estimate)) )
1069 SCIPinfoMessage(scip, file, " -- ");
1070 else
1071 SCIPinfoMessage(scip, file, "%13.6e ", estimate);
1072
1073 return SCIP_OKAY;
1074}
1075
1076/** output method of display column to output file stream 'file' for average dualbound */
1077static
1078SCIP_DECL_DISPOUTPUT(SCIPdispOutputAvgDualbound)
1079{ /*lint --e{715}*/
1080 SCIP_Real avgdualbound;
1081
1082 assert(disp != NULL);
1083 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_AVGDUALBOUND) == 0);
1084 assert(scip != NULL);
1085
1086 avgdualbound = SCIPgetAvgDualbound(scip);
1087 if( SCIPisInfinity(scip, REALABS(avgdualbound)) )
1088 SCIPinfoMessage(scip, file, " -- ");
1089 else
1090 SCIPinfoMessage(scip, file, "%13.6e ", avgdualbound);
1091
1092 return SCIP_OKAY;
1093}
1094
1095/** output method of display column to output file stream 'file' for dualbound */
1096static
1097SCIP_DECL_DISPOUTPUT(SCIPdispOutputDualbound)
1098{ /*lint --e{715}*/
1099 SCIP_Real dualbound;
1100
1101 assert(disp != NULL);
1102 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_DUALBOUND) == 0);
1103 assert(scip != NULL);
1104
1105 dualbound = SCIPgetDualbound(scip);
1106
1107 if( SCIPisInfinity(scip, (SCIP_Real) SCIPgetObjsense(scip) * dualbound ) )
1108 SCIPinfoMessage(scip, file, " cutoff ");
1109 else if( SCIPisInfinity(scip, -1.0 * (SCIP_Real) SCIPgetObjsense(scip) * dualbound ) )
1110 SCIPinfoMessage(scip, file, " -- ");
1111 else
1112 SCIPinfoMessage(scip, file, "%13.6e ", dualbound);
1113
1114 return SCIP_OKAY;
1115}
1116
1117/** output method of display column to output file stream 'file' for primalbound */
1118static
1119SCIP_DECL_DISPOUTPUT(SCIPdispOutputPrimalbound)
1120{ /*lint --e{715}*/
1121 SCIP_Real primalbound;
1122
1123 assert(disp != NULL);
1124 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_PRIMALBOUND) == 0);
1125 assert(scip != NULL);
1126
1127 primalbound = SCIPgetPrimalbound(scip);
1128 if( SCIPisInfinity(scip, REALABS(primalbound)) )
1129 SCIPinfoMessage(scip, file, " -- ");
1130 else
1131 SCIPinfoMessage(scip, file, "%13.6e%c", primalbound, SCIPisPrimalboundSol(scip) ? ' ' : '*');
1132
1133 return SCIP_OKAY;
1134}
1135
1136/** output method of display column to output file stream 'file' for dualbound */
1137static
1138SCIP_DECL_DISPOUTPUT(SCIPdispOutputConcDualbound)
1139{ /*lint --e{715}*/
1140 SCIP_Real dualbound;
1141
1142 assert(disp != NULL);
1143 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_CONCDUALBOUND) == 0);
1144 assert(scip != NULL);
1145
1146 dualbound = SCIPgetConcurrentDualbound(scip);
1147
1148 if( SCIPisInfinity(scip, (SCIP_Real) SCIPgetObjsense(scip) * dualbound ) )
1149 SCIPinfoMessage(scip, file, " cutoff ");
1150 else if( SCIPisInfinity(scip, -1.0 * (SCIP_Real) SCIPgetObjsense(scip) * dualbound ) )
1151 SCIPinfoMessage(scip, file, " -- ");
1152 else
1153 SCIPinfoMessage(scip, file, "%13.6e ", dualbound);
1154
1155 return SCIP_OKAY;
1156}
1157
1158/** output method of display column to output file stream 'file' for primalbound */
1159static
1160SCIP_DECL_DISPOUTPUT(SCIPdispOutputConcPrimalbound)
1161{ /*lint --e{715}*/
1162 SCIP_Real primalbound;
1163
1164 assert(disp != NULL);
1165 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_CONCPRIMALBOUND) == 0);
1166 assert(scip != NULL);
1167
1168 primalbound = SCIPgetConcurrentPrimalbound(scip);
1169 if( SCIPisInfinity(scip, REALABS(primalbound)) )
1170 SCIPinfoMessage(scip, file, " -- ");
1171 else
1172 SCIPinfoMessage(scip, file, "%13.6e ", primalbound);
1173
1174 return SCIP_OKAY;
1175}
1176
1177/** output method of display column to output file stream 'file' for cutoffbound */
1178static
1179SCIP_DECL_DISPOUTPUT(SCIPdispOutputCutoffbound)
1180{ /*lint --e{715}*/
1181 SCIP_Real cutoffbound;
1182
1183 assert(disp != NULL);
1184 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_CUTOFFBOUND) == 0);
1185 assert(scip != NULL);
1186
1187 cutoffbound = SCIPgetCutoffbound(scip);
1188 if( SCIPisInfinity(scip, REALABS(cutoffbound)) )
1189 SCIPinfoMessage(scip, file, " -- ");
1190 else
1191 SCIPinfoMessage(scip, file, "%13.6e ", SCIPretransformObj(scip, cutoffbound));
1192
1193 return SCIP_OKAY;
1194}
1195
1196/** output method of display column to output file stream 'file' for gap */
1197static
1198SCIP_DECL_DISPOUTPUT(SCIPdispOutputGap)
1199{ /*lint --e{715}*/
1200 SCIP_Real gap;
1201
1202 assert(disp != NULL);
1203 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_GAP) == 0);
1204 assert(scip != NULL);
1205
1206 gap = SCIPgetGap(scip);
1207
1208 if( SCIPisInfinity(scip, gap) )
1209 SCIPinfoMessage(scip, file, " Inf ");
1210 else if( gap >= 100.00 )
1211 SCIPinfoMessage(scip, file, " Large ");
1212 else
1213 SCIPinfoMessage(scip, file, "%7.2f%%", 100.0*gap);
1214
1215 return SCIP_OKAY;
1216}
1217
1218/** output method of display column to output file stream 'file' for gap */
1219static
1220SCIP_DECL_DISPOUTPUT(SCIPdispOutputConcGap)
1221{ /*lint --e{715}*/
1222 SCIP_Real gap;
1223
1224 assert(disp != NULL);
1225 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_CONCGAP) == 0);
1226 assert(scip != NULL);
1227
1229
1230 if( SCIPisInfinity(scip, gap) )
1231 SCIPinfoMessage(scip, file, " Inf ");
1232 else if( gap >= 100.00 )
1233 SCIPinfoMessage(scip, file, " Large ");
1234 else
1235 SCIPinfoMessage(scip, file, "%7.2f%%", 100.0*gap);
1236
1237 return SCIP_OKAY;
1238}
1239
1240/** output method of display column to output file stream 'file' for primalgap */
1241static
1242SCIP_DECL_DISPOUTPUT(SCIPdispOutputPrimalgap)
1243{ /*lint --e{715}*/
1244 SCIP_Real primalbound;
1245 SCIP_Real dualbound;
1246 SCIP_Real gap;
1247
1248 assert(disp != NULL);
1249 assert(strcmp(SCIPdispGetName(disp), DISP_NAME_PRIMALGAP) == 0);
1250 assert(scip != NULL);
1251
1253 {
1254 /* in case we could not prove whether the problem is unbounded or infeasible, we want to terminate with
1255 * gap = +inf instead of gap = 0
1256 */
1258 gap = SCIPinfinity(scip);
1259 else
1260 gap = 0.0;
1261 }
1262 else
1263 {
1264 primalbound = SCIPgetPrimalbound(scip);
1265 dualbound = SCIPgetDualbound(scip);
1266
1267 if( SCIPisEQ(scip, primalbound, dualbound) )
1268 gap = 0.0;
1269 else if( SCIPisZero(scip, primalbound)
1270 || SCIPisInfinity(scip, REALABS(primalbound))
1271 || primalbound * dualbound < 0.0 )
1272 gap = SCIPinfinity(scip);
1273 else
1274 gap = REALABS((primalbound - dualbound))/REALABS(primalbound + SCIPepsilon(scip));
1275 }
1276
1277 if( SCIPisInfinity(scip, gap) )
1278 SCIPinfoMessage(scip, file, " Inf ");
1279 else if( gap >= 100.00 )
1280 SCIPinfoMessage(scip, file, " Large ");
1281 else
1282 SCIPinfoMessage(scip, file, "%7.2f%%", 100.0*gap);
1283
1284 return SCIP_OKAY;
1285}
1286
1287/** output method of display column to output file stream 'file' for number of found solutions */
1288static
1289SCIP_DECL_DISPOUTPUT(SCIPdispOutputNSols)
1290{ /*lint --e{715}*/
1292
1293 return SCIP_OKAY;
1294}
1295
1296/*
1297 * default display columns specific interface methods
1298 */
1299
1300/** includes the default display columns in SCIP */
1302 SCIP* scip /**< SCIP data structure */
1303 )
1304{
1305 SCIP_DISP* tmpdisp;
1306
1308
1309 /* since the default display columns are always included all at once in this method,
1310 * they should all be included already if the first one is */
1311 if( tmpdisp != NULL )
1312 {
1314 assert(SCIPfindDisp(scip, DISP_NAME_TIME) != NULL );
1315 assert(SCIPfindDisp(scip, DISP_NAME_NNODES) != NULL );
1319 assert(SCIPfindDisp(scip, DISP_NAME_LPCOND) != NULL );
1323 assert(SCIPfindDisp(scip, DISP_NAME_DEPTH) != NULL );
1326 assert(SCIPfindDisp(scip, DISP_NAME_NFRAC) != NULL );
1328 assert(SCIPfindDisp(scip, DISP_NAME_VARS) != NULL );
1329 assert(SCIPfindDisp(scip, DISP_NAME_CONSS) != NULL );
1333 assert(SCIPfindDisp(scip, DISP_NAME_CUTS) != NULL );
1339 assert(SCIPfindDisp(scip, DISP_NAME_LPOBJ) != NULL );
1348 assert(SCIPfindDisp(scip, DISP_NAME_GAP) != NULL );
1351 assert(SCIPfindDisp(scip, DISP_NAME_NSOLS) != NULL );
1354
1355 return SCIP_OKAY;
1356 }
1357
1360 dispCopyDefault,
1361 NULL, NULL, NULL, SCIPdispInitsolSolFound, NULL, SCIPdispOutputSolFound, NULL,
1363
1367 dispCopyDefault,
1368 NULL, NULL, NULL, SCIPdispInitsolConcSolFound, SCIPdispExitsolConcSolFound, SCIPdispOutputConcSolFound, NULL,
1372
1373 assert(SCIPfindDisp(scip, DISP_NAME_TIME) == NULL);
1376 dispCopyDefault,
1377 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputSolvingTime, NULL,
1379 tmpdisp = SCIPfindDisp(scip, DISP_NAME_TIME);
1381
1385 dispCopyDefault,
1386 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNNodes, NULL,
1388
1392 dispCopyDefault,
1393 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNNodesLeft, NULL,
1395
1396 /* add objective leaves display */
1401
1402 /* add infeasible leaves display */
1407
1411 dispCopyDefault,
1412 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNLPIterations, NULL,
1414
1418 dispCopyDefault,
1419 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNLPAvgIters, NULL,
1421
1425 dispCopyDefault,
1426 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputLPCondition, NULL,
1428
1432 dispCopyDefault,
1433 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputMemUsed, NULL,
1435
1439 dispCopyDefault,
1440 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputConcMemUsed, NULL,
1444
1448 dispCopyDefault,
1449 NULL, NULL, NULL, SCIPdispInitsolSolFound, NULL, SCIPdispOutputMemUsedTotal, NULL,
1451
1455 dispCopyDefault,
1456 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputDepth, NULL,
1458
1462 dispCopyDefault,
1463 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputMaxDepth, NULL,
1465
1469 dispCopyDefault,
1470 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputPlungeDepth, NULL,
1472
1476 dispCopyDefault,
1477 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNFrac, NULL,
1479
1483 dispCopyDefault,
1484 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNExternCands, NULL,
1486
1487 assert(SCIPfindDisp(scip, DISP_NAME_VARS) == NULL);
1490 dispCopyDefault,
1491 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNVars, NULL,
1493
1497 dispCopyDefault,
1498 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNConss, NULL,
1500
1504 dispCopyDefault,
1505 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNCurConss, NULL,
1507
1511 dispCopyDefault,
1512 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNCurCols, NULL,
1514
1518 dispCopyDefault,
1519 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNCurRows, NULL,
1521
1522 assert(SCIPfindDisp(scip, DISP_NAME_CUTS) == NULL);
1525 dispCopyDefault,
1526 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNAppliedCuts, NULL,
1528
1532 dispCopyDefault,
1533 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNSepaRounds, NULL,
1535
1539 dispCopyDefault,
1540 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputCutPoolSize, NULL,
1542
1546 dispCopyDefault,
1547 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNConflicts, NULL,
1549
1553 dispCopyDefault,
1554 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNStrongbranchs, NULL,
1556
1560 dispCopyDefault,
1561 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputPseudoObjval, NULL,
1563
1567 dispCopyDefault,
1568 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputLPObjval, NULL,
1570
1574 dispCopyDefault,
1575 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputCurDualbound, NULL,
1577
1581 dispCopyDefault,
1582 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputLocalOrigEstimate, NULL,
1584
1588 dispCopyDefault,
1589 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputAvgDualbound, NULL,
1591
1595 dispCopyDefault,
1596 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputDualbound, NULL,
1598
1602 dispCopyDefault,
1603 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputPrimalbound, NULL,
1605
1609 dispCopyDefault,
1610 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputConcDualbound, NULL,
1614
1618 dispCopyDefault,
1619 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputConcPrimalbound, NULL,
1623
1627 dispCopyDefault,
1628 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputCutoffbound, NULL,
1630
1631 assert(SCIPfindDisp(scip, DISP_NAME_GAP) == NULL);
1634 dispCopyDefault,
1635 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputGap, NULL,
1637
1641 dispCopyDefault,
1642 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputConcGap, NULL,
1646
1650 dispCopyDefault,
1651 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputPrimalgap, NULL,
1653
1657 dispCopyDefault,
1658 NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNSols, NULL,
1660
1661 return SCIP_OKAY;
1662}
1663
SCIP_Real SCIPgetConcurrentDualbound(SCIP *scip)
Definition: concurrent.c:306
SCIP_Real SCIPgetConcurrentPrimalbound(SCIP *scip)
Definition: concurrent.c:321
SCIP_Real SCIPgetConcurrentGap(SCIP *scip)
Definition: concurrent.c:336
helper functions for concurrent scip solvers
#define NULL
Definition: def.h:267
#define SCIP_Longint
Definition: def.h:158
#define SCIP_INVALID
Definition: def.h:193
#define SCIP_Bool
Definition: def.h:91
#define SCIP_Real
Definition: def.h:173
#define SCIP_LONGINT_FORMAT
Definition: def.h:165
#define REALABS(x)
Definition: def.h:197
#define SCIP_CALL(x)
Definition: def.h:374
#define DISP_WIDT_LPITERATIONS
Definition: disp_default.c:103
#define DISP_WIDT_GAP
Definition: disp_default.c:352
#define DISP_WIDT_NINFEASLEAVES
Definition: disp_default.c:395
#define DISP_HEAD_MEMTOTAL
Definition: disp_default.c:142
#define DISP_WIDT_CURROWS
Definition: disp_default.c:224
#define DISP_PRIO_PRIMALGAP
Definition: disp_default.c:369
#define DISP_STRI_CONFLICTS
Definition: disp_default.c:259
#define DISP_WIDT_LPCOND
Definition: disp_default.c:119
#define DISP_WIDT_POOLSIZE
Definition: disp_default.c:248
#define DISP_WIDT_CURCONSS
Definition: disp_default.c:208
#define DISP_WIDT_SEPAROUNDS
Definition: disp_default.c:240
#define DISP_NAME_SOLFOUND
Definition: disp_default.c:59
#define DISP_HEAD_DEPTH
Definition: disp_default.c:151
#define DISP_NAME_NODESLEFT
Definition: disp_default.c:91
#define DISP_PRIO_POOLSIZE
Definition: disp_default.c:249
#define DISP_NAME_PRIMALGAP
Definition: disp_default.c:365
#define DISP_PRIO_CONCSOLFOUND
Definition: disp_default.c:71
#define DISP_DESC_ESTIMATE
Definition: disp_default.c:294
#define DISP_POSI_DUALBOUND
Definition: disp_default.c:314
#define DISP_POSI_AVGDUALBOUND
Definition: disp_default.c:306
#define DISP_PRIO_NNODES
Definition: disp_default.c:87
#define DISP_DESC_CURCOLS
Definition: disp_default.c:214
#define DISP_POSI_LPAVGITERS
Definition: disp_default.c:113
#define DISP_WIDT_CONFLICTS
Definition: disp_default.c:256
#define DISP_NAME_CURCONSS
Definition: disp_default.c:205
#define DISP_DESC_NNODES
Definition: disp_default.c:84
#define DISP_POSI_STRONGBRANCHS
Definition: disp_default.c:266
#define DISP_DESC_MEMUSED
Definition: disp_default.c:125
#define DISP_WIDT_MAXDEPTH
Definition: disp_default.c:160
#define DISP_STRI_NINFEASLEAVES
Definition: disp_default.c:398
#define DISP_PRIO_GAP
Definition: disp_default.c:353
#define DISP_NAME_TIME
Definition: disp_default.c:75
#define DISP_POSI_MEMTOTAL
Definition: disp_default.c:146
#define DISP_POSI_CURDUALBOUND
Definition: disp_default.c:290
#define DISP_NAME_NOBJLEAVES
Definition: disp_default.c:382
#define DISP_DESC_CONCDUALBOUND
Definition: disp_default.c:318
#define DISP_HEAD_ESTIMATE
Definition: disp_default.c:295
#define DISP_PRIO_ESTIMATE
Definition: disp_default.c:297
#define DISP_HEAD_NINFEASLEAVES
Definition: disp_default.c:394
#define DISP_PRIO_CUTS
Definition: disp_default.c:233
#define DISP_PRIO_LPCOND
Definition: disp_default.c:120
#define DISP_PRIO_NOBJLEAVES
Definition: disp_default.c:386
#define DISP_NAME_CUTOFFBOUND
Definition: disp_default.c:341
#define DISP_POSI_PRIMALGAP
Definition: disp_default.c:370
#define DISP_DESC_CURCONSS
Definition: disp_default.c:206
#define DISP_NAME_CONCGAP
Definition: disp_default.c:357
#define DISP_STRI_STRONGBRANCHS
Definition: disp_default.c:267
#define DISP_PRIO_CURCONSS
Definition: disp_default.c:209
#define DISP_NAME_CONCPRIMALBOUND
Definition: disp_default.c:333
#define DISP_WIDT_PLUNGEDEPTH
Definition: disp_default.c:168
#define DISP_PRIO_PRIMALBOUND
Definition: disp_default.c:329
#define DISP_WIDT_CONCPRIMALBOUND
Definition: disp_default.c:336
#define DISP_POSI_TIME
Definition: disp_default.c:80
#define DISP_STRI_POOLSIZE
Definition: disp_default.c:251
#define DISP_STRI_MEMTOTAL
Definition: disp_default.c:147
#define DISP_POSI_CONCMEMUSED
Definition: disp_default.c:137
#define DISP_POSI_NNODES
Definition: disp_default.c:88
#define DISP_PRIO_PLUNGEDEPTH
Definition: disp_default.c:169
#define DISP_HEAD_NODESLEFT
Definition: disp_default.c:93
#define DISP_PRIO_CURDUALBOUND
Definition: disp_default.c:289
#define DISP_HEAD_CUTOFFBOUND
Definition: disp_default.c:343
#define DISP_WIDT_NSOLS
Definition: disp_default.c:376
#define DISP_STRI_TIME
Definition: disp_default.c:81
#define DISP_POSI_GAP
Definition: disp_default.c:354
#define DISP_DESC_NOBJLEAVES
Definition: disp_default.c:383
#define DISP_POSI_CONCSOLFOUND
Definition: disp_default.c:72
#define DISP_NAME_CURROWS
Definition: disp_default.c:221
#define DISP_STRI_CURCONSS
Definition: disp_default.c:211
#define DISP_DESC_LPOBJ
Definition: disp_default.c:278
#define DISP_WIDT_PRIMALBOUND
Definition: disp_default.c:328
#define DISP_HEAD_CONSS
Definition: disp_default.c:199
#define DISP_POSI_CURCOLS
Definition: disp_default.c:218
#define DISP_NAME_CONCMEMUSED
Definition: disp_default.c:132
#define DISP_NAME_NSOLS
Definition: disp_default.c:373
#define DISP_PRIO_MAXDEPTH
Definition: disp_default.c:161
#define DISP_HEAD_CURCOLS
Definition: disp_default.c:215
#define DISP_PRIO_NODESLEFT
Definition: disp_default.c:95
#define DISP_DESC_AVGDUALBOUND
Definition: disp_default.c:302
static SCIP_Bool isDisplaySol(SCIP *scip, SCIP_SOL *sol)
Definition: disp_default.c:436
#define DISP_STRI_DEPTH
Definition: disp_default.c:155
#define DISP_HEAD_CONCPRIMALBOUND
Definition: disp_default.c:335
#define DISP_NAME_CONCDUALBOUND
Definition: disp_default.c:317
#define DISP_WIDT_MEMTOTAL
Definition: disp_default.c:143
#define DISP_NAME_MEMUSED
Definition: disp_default.c:124
#define DISP_STRI_NNODES
Definition: disp_default.c:89
#define DISP_POSI_CONCPRIMALBOUND
Definition: disp_default.c:338
#define DISP_PRIO_CONCDUALBOUND
Definition: disp_default.c:321
#define DISP_DESC_CURDUALBOUND
Definition: disp_default.c:286
#define DISP_DESC_DUALBOUND
Definition: disp_default.c:310
#define DISP_PRIO_SEPAROUNDS
Definition: disp_default.c:241
#define DISP_PRIO_TIME
Definition: disp_default.c:79
#define DISP_NAME_CUTS
Definition: disp_default.c:229
#define DISP_STRI_CURCOLS
Definition: disp_default.c:219
#define DISP_WIDT_CONSS
Definition: disp_default.c:200
#define DISP_DESC_LPCOND
Definition: disp_default.c:117
#define DISP_STRI_NSOLS
Definition: disp_default.c:379
#define DISP_HEAD_CONCSOLFOUND
Definition: disp_default.c:69
#define DISP_WIDT_NODESLEFT
Definition: disp_default.c:94
#define DISP_HEAD_PSEUDOOBJ
Definition: disp_default.c:271
#define DISP_HEAD_CONCMEMUSED
Definition: disp_default.c:134
#define DISP_NAME_LPAVGITERS
Definition: disp_default.c:108
#define DISP_PRIO_LPOBJ
Definition: disp_default.c:281
#define DISP_POSI_CONSS
Definition: disp_default.c:202
#define DISP_HEAD_NFRAC
Definition: disp_default.c:175
#define DISP_DESC_MAXDEPTH
Definition: disp_default.c:158
#define DISP_WIDT_NFRAC
Definition: disp_default.c:176
#define DISP_POSI_PRIMALBOUND
Definition: disp_default.c:330
#define DISP_POSI_NODESLEFT
Definition: disp_default.c:96
#define DISP_PRIO_MEMUSED
Definition: disp_default.c:128
#define DISP_POSI_NOBJLEAVES
Definition: disp_default.c:387
#define DISP_HEAD_NEXTERNCANDS
Definition: disp_default.c:183
#define DISP_WIDT_PRIMALGAP
Definition: disp_default.c:368
#define DISP_PRIO_CONCPRIMALBOUND
Definition: disp_default.c:337
#define DISP_POSI_PLUNGEDEPTH
Definition: disp_default.c:170
#define DISP_STRI_LPITERATIONS
Definition: disp_default.c:106
#define DISP_STRI_CUTS
Definition: disp_default.c:235
#define DISP_POSI_LPOBJ
Definition: disp_default.c:282
#define DISP_STRI_LPOBJ
Definition: disp_default.c:283
#define DISP_STRI_DUALBOUND
Definition: disp_default.c:315
#define DISP_STRI_CONCSOLFOUND
Definition: disp_default.c:73
#define DISP_STRI_AVGDUALBOUND
Definition: disp_default.c:307
#define DISP_POSI_LPITERATIONS
Definition: disp_default.c:105
#define DISP_HEAD_TIME
Definition: disp_default.c:77
#define DISP_POSI_NEXTERNCANDS
Definition: disp_default.c:186
#define DISP_HEAD_SOLFOUND
Definition: disp_default.c:61
#define DISP_WIDT_PSEUDOOBJ
Definition: disp_default.c:272
#define DISP_DESC_PRIMALBOUND
Definition: disp_default.c:326
#define DISP_POSI_ESTIMATE
Definition: disp_default.c:298
#define DISP_HEAD_DUALBOUND
Definition: disp_default.c:311
#define DISP_DESC_LPITERATIONS
Definition: disp_default.c:101
#define DISP_NAME_NFRAC
Definition: disp_default.c:173
#define DISP_STRI_PRIMALGAP
Definition: disp_default.c:371
#define DISP_DESC_PSEUDOOBJ
Definition: disp_default.c:270
#define DISP_DESC_PRIMALGAP
Definition: disp_default.c:366
#define DISP_STRI_CURROWS
Definition: disp_default.c:227
#define DISP_WIDT_LPAVGITERS
Definition: disp_default.c:111
#define DISP_WIDT_CURDUALBOUND
Definition: disp_default.c:288
#define DISP_DESC_CUTOFFBOUND
Definition: disp_default.c:342
#define DISP_NAME_DEPTH
Definition: disp_default.c:149
#define DISP_NAME_LPOBJ
Definition: disp_default.c:277
#define DISP_STRI_LPAVGITERS
Definition: disp_default.c:114
#define DISP_HEAD_NNODES
Definition: disp_default.c:85
#define DISP_DESC_SOLFOUND
Definition: disp_default.c:60
#define DISP_HEAD_LPOBJ
Definition: disp_default.c:279
#define DISP_DESC_CONSS
Definition: disp_default.c:198
#define DISP_STRI_NOBJLEAVES
Definition: disp_default.c:388
#define DISP_NAME_SEPAROUNDS
Definition: disp_default.c:237
#define DISP_WIDT_VARS
Definition: disp_default.c:192
#define DISP_STRI_PSEUDOOBJ
Definition: disp_default.c:275
#define DISP_STRI_CONCPRIMALBOUND
Definition: disp_default.c:339
#define DISP_STRI_PRIMALBOUND
Definition: disp_default.c:331
#define DISP_DESC_VARS
Definition: disp_default.c:190
static SCIP_DECL_DISPCOPY(dispCopyDefault)
Definition: disp_default.c:406
#define DISP_POSI_POOLSIZE
Definition: disp_default.c:250
static SCIP_DECL_DISPOUTPUT(SCIPdispOutputSolFound)
Definition: disp_default.c:446
#define DISP_POSI_CUTOFFBOUND
Definition: disp_default.c:346
#define DISP_WIDT_CONCSOLFOUND
Definition: disp_default.c:70
#define DISP_DESC_STRONGBRANCHS
Definition: disp_default.c:262
#define DISP_HEAD_PRIMALGAP
Definition: disp_default.c:367
#define DISP_HEAD_MAXDEPTH
Definition: disp_default.c:159
#define DISP_POSI_VARS
Definition: disp_default.c:194
#define DISP_WIDT_ESTIMATE
Definition: disp_default.c:296
#define DISP_HEAD_CONFLICTS
Definition: disp_default.c:255
#define DISP_PRIO_CURROWS
Definition: disp_default.c:225
#define DISP_NAME_PRIMALBOUND
Definition: disp_default.c:325
#define DISP_WIDT_MEMUSED
Definition: disp_default.c:127
#define DISP_STRI_NFRAC
Definition: disp_default.c:179
#define DISP_HEAD_CUTS
Definition: disp_default.c:231
#define DISP_PRIO_DUALBOUND
Definition: disp_default.c:313
#define DISP_DESC_NFRAC
Definition: disp_default.c:174
#define DISP_WIDT_CURCOLS
Definition: disp_default.c:216
static SCIP_DECL_DISPINITSOL(SCIPdispInitsolSolFound)
Definition: disp_default.c:422
#define DISP_POSI_CONCDUALBOUND
Definition: disp_default.c:322
#define DISP_WIDT_CUTOFFBOUND
Definition: disp_default.c:344
#define DISP_POSI_SEPAROUNDS
Definition: disp_default.c:242
#define DISP_WIDT_LPOBJ
Definition: disp_default.c:280
#define DISP_WIDT_CUTS
Definition: disp_default.c:232
#define DISP_POSI_NFRAC
Definition: disp_default.c:178
#define DISP_POSI_DEPTH
Definition: disp_default.c:154
#define DISP_WIDT_TIME
Definition: disp_default.c:78
#define DISP_DESC_CONCMEMUSED
Definition: disp_default.c:133
#define DISP_HEAD_CURCONSS
Definition: disp_default.c:207
#define DISP_PRIO_NINFEASLEAVES
Definition: disp_default.c:396
#define DISP_PRIO_NSOLS
Definition: disp_default.c:377
#define DISP_HEAD_CURDUALBOUND
Definition: disp_default.c:287
#define DISP_NAME_CONSS
Definition: disp_default.c:197
#define DISP_STRI_CONCDUALBOUND
Definition: disp_default.c:323
#define DISP_PRIO_NFRAC
Definition: disp_default.c:177
#define DISP_NAME_CONFLICTS
Definition: disp_default.c:253
#define DISP_POSI_NSOLS
Definition: disp_default.c:378
#define DISP_HEAD_STRONGBRANCHS
Definition: disp_default.c:263
#define DISP_HEAD_CONCGAP
Definition: disp_default.c:359
#define DISP_WIDT_CONCDUALBOUND
Definition: disp_default.c:320
#define DISP_STRI_PLUNGEDEPTH
Definition: disp_default.c:171
#define DISP_DESC_NINFEASLEAVES
Definition: disp_default.c:393
#define DISP_WIDT_DUALBOUND
Definition: disp_default.c:312
#define DISP_STRI_CONCGAP
Definition: disp_default.c:363
#define DISP_NAME_CONCSOLFOUND
Definition: disp_default.c:67
#define DISP_NAME_DUALBOUND
Definition: disp_default.c:309
#define DISP_DESC_POOLSIZE
Definition: disp_default.c:246
#define DISP_POSI_CONFLICTS
Definition: disp_default.c:258
#define DISP_HEAD_AVGDUALBOUND
Definition: disp_default.c:303
#define DISP_HEAD_MEMUSED
Definition: disp_default.c:126
#define DISP_DESC_CONCGAP
Definition: disp_default.c:358
#define DISP_HEAD_POOLSIZE
Definition: disp_default.c:247
#define DISP_WIDT_CONCGAP
Definition: disp_default.c:360
#define DISP_STRI_VARS
Definition: disp_default.c:195
#define DISP_PRIO_CONCMEMUSED
Definition: disp_default.c:136
#define DISP_STRI_SOLFOUND
Definition: disp_default.c:65
#define DISP_NAME_POOLSIZE
Definition: disp_default.c:245
#define DISP_WIDT_AVGDUALBOUND
Definition: disp_default.c:304
#define DISP_PRIO_CUTOFFBOUND
Definition: disp_default.c:345
#define DISP_WIDT_SOLFOUND
Definition: disp_default.c:62
#define DISP_NAME_NINFEASLEAVES
Definition: disp_default.c:392
#define DISP_POSI_CURCONSS
Definition: disp_default.c:210
#define DISP_STRI_MEMUSED
Definition: disp_default.c:130
#define DISP_PRIO_NEXTERNCANDS
Definition: disp_default.c:185
#define DISP_WIDT_NOBJLEAVES
Definition: disp_default.c:385
#define DISP_POSI_NINFEASLEAVES
Definition: disp_default.c:397
#define DISP_POSI_LPCOND
Definition: disp_default.c:121
#define DISP_HEAD_VARS
Definition: disp_default.c:191
#define DISP_DESC_PLUNGEDEPTH
Definition: disp_default.c:166
#define DISP_HEAD_LPITERATIONS
Definition: disp_default.c:102
#define DISP_HEAD_LPCOND
Definition: disp_default.c:118
#define DISP_NAME_MEMTOTAL
Definition: disp_default.c:140
#define DISP_DESC_SEPAROUNDS
Definition: disp_default.c:238
#define DISP_NAME_MAXDEPTH
Definition: disp_default.c:157
#define DISP_DESC_NODESLEFT
Definition: disp_default.c:92
#define DISP_PRIO_SOLFOUND
Definition: disp_default.c:63
#define DISP_WIDT_DEPTH
Definition: disp_default.c:152
#define DISP_DESC_GAP
Definition: disp_default.c:350
#define DISP_WIDT_STRONGBRANCHS
Definition: disp_default.c:264
#define DISP_NAME_LPCOND
Definition: disp_default.c:116
#define DISP_STRI_CURDUALBOUND
Definition: disp_default.c:291
#define DISP_WIDT_NNODES
Definition: disp_default.c:86
#define DISP_NAME_AVGDUALBOUND
Definition: disp_default.c:301
#define DISP_NAME_NEXTERNCANDS
Definition: disp_default.c:181
#define DISP_DESC_CUTS
Definition: disp_default.c:230
#define DISP_PRIO_DEPTH
Definition: disp_default.c:153
#define DISP_DESC_NSOLS
Definition: disp_default.c:374
#define DISP_PRIO_PSEUDOOBJ
Definition: disp_default.c:273
#define DISP_DESC_CONFLICTS
Definition: disp_default.c:254
#define DISP_WIDT_MEMONLY
Definition: disp_default.c:144
#define DISP_PRIO_CONSS
Definition: disp_default.c:201
#define DISP_DESC_NEXTERNCANDS
Definition: disp_default.c:182
#define DISP_PRIO_MEMTOTAL
Definition: disp_default.c:145
#define DISP_HEAD_GAP
Definition: disp_default.c:351
#define DISP_DESC_CONCSOLFOUND
Definition: disp_default.c:68
#define DISP_HEAD_SEPAROUNDS
Definition: disp_default.c:239
#define DISP_POSI_SOLFOUND
Definition: disp_default.c:64
#define DISP_NAME_NNODES
Definition: disp_default.c:83
#define DISP_PRIO_CONFLICTS
Definition: disp_default.c:257
#define DISP_POSI_MAXDEPTH
Definition: disp_default.c:162
#define DISP_WIDT_CONCMEMUSED
Definition: disp_default.c:135
#define DISP_POSI_MEMUSED
Definition: disp_default.c:129
#define DISP_NAME_VARS
Definition: disp_default.c:189
#define DISP_HEAD_NSOLS
Definition: disp_default.c:375
#define DISP_STRI_CONCMEMUSED
Definition: disp_default.c:138
#define DISP_STRI_NODESLEFT
Definition: disp_default.c:97
#define DISP_DESC_MEMTOTAL
Definition: disp_default.c:141
#define DISP_POSI_CUTS
Definition: disp_default.c:234
#define DISP_STRI_MAXDEPTH
Definition: disp_default.c:163
#define DISP_PRIO_LPITERATIONS
Definition: disp_default.c:104
#define DISP_HEAD_PRIMALBOUND
Definition: disp_default.c:327
#define DISP_DESC_DEPTH
Definition: disp_default.c:150
#define DISP_STRI_SEPAROUNDS
Definition: disp_default.c:243
#define DISP_STRI_CONSS
Definition: disp_default.c:203
#define DISP_STRI_NEXTERNCANDS
Definition: disp_default.c:187
#define DISP_PRIO_STRONGBRANCHS
Definition: disp_default.c:265
#define DISP_POSI_CONCGAP
Definition: disp_default.c:362
#define DISP_NAME_LPITERATIONS
Definition: disp_default.c:100
#define DISP_DESC_CONCPRIMALBOUND
Definition: disp_default.c:334
#define DISP_PRIO_AVGDUALBOUND
Definition: disp_default.c:305
#define DISP_NAME_STRONGBRANCHS
Definition: disp_default.c:261
#define DISP_PRIO_VARS
Definition: disp_default.c:193
#define DISP_STRI_CUTOFFBOUND
Definition: disp_default.c:347
#define DISP_HEAD_CONCDUALBOUND
Definition: disp_default.c:319
#define DISP_STRI_LPCOND
Definition: disp_default.c:122
#define DISP_STRI_ESTIMATE
Definition: disp_default.c:299
#define DISP_DESC_LPAVGITERS
Definition: disp_default.c:109
#define DISP_DESC_TIME
Definition: disp_default.c:76
#define DISP_NAME_CURDUALBOUND
Definition: disp_default.c:285
#define DISP_NAME_GAP
Definition: disp_default.c:349
#define DISP_HEAD_NOBJLEAVES
Definition: disp_default.c:384
#define DISP_NAME_PSEUDOOBJ
Definition: disp_default.c:269
#define DISP_PRIO_CONCGAP
Definition: disp_default.c:361
#define DISP_HEAD_PLUNGEDEPTH
Definition: disp_default.c:167
#define DISP_STRI_GAP
Definition: disp_default.c:355
#define DISP_WIDT_NEXTERNCANDS
Definition: disp_default.c:184
#define DISP_NAME_ESTIMATE
Definition: disp_default.c:293
#define DISP_NAME_PLUNGEDEPTH
Definition: disp_default.c:165
#define DISP_POSI_PSEUDOOBJ
Definition: disp_default.c:274
#define DISP_DESC_CURROWS
Definition: disp_default.c:222
#define DISP_HEAD_LPAVGITERS
Definition: disp_default.c:110
#define DISP_PRIO_LPAVGITERS
Definition: disp_default.c:112
#define DISP_PRIO_CURCOLS
Definition: disp_default.c:217
#define DISP_HEAD_CURROWS
Definition: disp_default.c:223
#define DISP_POSI_CURROWS
Definition: disp_default.c:226
#define DISP_NAME_CURCOLS
Definition: disp_default.c:213
default display columns
SCIP_RETCODE SCIPincludeDispDefault(SCIP *scip)
SCIP_STATUS SCIPgetStatus(SCIP *scip)
Definition: scip_general.c:498
int SCIPgetNVars(SCIP *scip)
Definition: scip_prob.c:1992
int SCIPgetNConss(SCIP *scip)
Definition: scip_prob.c:3042
SCIP_OBJSENSE SCIPgetObjsense(SCIP *scip)
Definition: scip_prob.c:1225
SCIP_RETCODE SCIPlpiGetRealSolQuality(SCIP_LPI *lpi, SCIP_LPSOLQUALITY qualityindicator, SCIP_Real *quality)
Definition: lpi_clp.cpp:2940
SCIP_Real SCIPgetLocalOrigEstimate(SCIP *scip)
Definition: scip_prob.c:3527
SCIP_Real SCIPgetLocalDualbound(SCIP *scip)
Definition: scip_prob.c:3566
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
Definition: scip_message.c:208
SCIP_MESSAGEHDLR * SCIPgetMessagehdlr(SCIP *scip)
Definition: scip_message.c:88
int SCIPgetNExternBranchCands(SCIP *scip)
Definition: scip_branch.c:543
int SCIPgetNLPBranchCands(SCIP *scip)
Definition: scip_branch.c:428
int SCIPgetNPoolCuts(SCIP *scip)
Definition: scip_cut.c:420
void SCIPdispLongint(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, SCIP_Longint val, int width)
Definition: disp.c:581
void SCIPdispSetData(SCIP_DISP *disp, SCIP_DISPDATA *dispdata)
Definition: disp.c:324
const char * SCIPdispGetName(SCIP_DISP *disp)
Definition: disp.c:335
SCIP_DISP * SCIPfindDisp(SCIP *scip, const char *name)
Definition: scip_disp.c:97
void SCIPdispTime(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, SCIP_Real val, int width)
Definition: disp.c:643
void SCIPdispInt(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, int val, int width)
Definition: disp.c:627
void SCIPchgDispMode(SCIP_DISP *disp, SCIP_DISPMODE mode)
Definition: scip_disp.c:145
SCIP_DISPDATA * SCIPdispGetData(SCIP_DISP *disp)
Definition: disp.c:314
SCIP_RETCODE SCIPincludeDisp(SCIP *scip, const char *name, const char *desc, const char *header, SCIP_DISPSTATUS dispstatus, SCIP_DECL_DISPCOPY((*dispcopy)), SCIP_DECL_DISPFREE((*dispfree)), SCIP_DECL_DISPINIT((*dispinit)), SCIP_DECL_DISPEXIT((*dispexit)), SCIP_DECL_DISPINITSOL((*dispinitsol)), SCIP_DECL_DISPEXITSOL((*dispexitsol)), SCIP_DECL_DISPOUTPUT((*dispoutput)), SCIP_DISPDATA *dispdata, int width, int priority, int position, SCIP_Bool stripline)
Definition: scip_disp.c:55
char SCIPheurGetDispchar(SCIP_HEUR *heur)
Definition: heur.c:1473
const char * SCIPheurGetName(SCIP_HEUR *heur)
Definition: heur.c:1453
SCIP_Bool SCIPhasCurrentNodeLP(SCIP *scip)
Definition: scip_lp.c:83
SCIP_Real SCIPgetPseudoObjval(SCIP *scip)
Definition: scip_lp.c:333
int SCIPgetNLPRows(SCIP *scip)
Definition: scip_lp.c:626
SCIP_RETCODE SCIPgetLPI(SCIP *scip, SCIP_LPI **lpi)
Definition: scip_lp.c:985
SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)
Definition: scip_lp.c:168
SCIP_Real SCIPgetLPObjval(SCIP *scip)
Definition: scip_lp.c:247
int SCIPgetNLPCols(SCIP *scip)
Definition: scip_lp.c:527
SCIP_Longint SCIPgetMemUsed(SCIP *scip)
Definition: scip_mem.c:100
#define SCIPfreeBlockMemory(scip, ptr)
Definition: scip_mem.h:108
SCIP_Longint SCIPgetMemTotal(SCIP *scip)
Definition: scip_mem.c:113
#define SCIPallocBlockMemory(scip, ptr)
Definition: scip_mem.h:89
SCIP_SYNCSTORE * SCIPgetSyncstore(SCIP *scip)
const char * SCIPrelaxGetName(SCIP_RELAX *relax)
Definition: relax.c:542
SCIP_SOL * SCIPgetBestSol(SCIP *scip)
Definition: scip_sol.c:2169
SCIP_HEUR * SCIPgetSolHeur(SCIP *scip, SCIP_SOL *sol)
Definition: scip_sol.c:1540
SCIP_RELAX * SCIPsolGetRelax(SCIP_SOL *sol)
Definition: sol.c:2876
SCIP_HEUR * SCIPsolGetHeur(SCIP_SOL *sol)
Definition: sol.c:2804
SCIP_Bool SCIPsolIsOriginal(SCIP_SOL *sol)
Definition: sol.c:2721
SCIP_SOLTYPE SCIPsolGetType(SCIP_SOL *sol)
Definition: sol.c:2866
SCIP_Real SCIPgetSolTransObj(SCIP *scip, SCIP_SOL *sol)
Definition: scip_sol.c:1347
SCIP_Real SCIPretransformObj(SCIP *scip, SCIP_Real obj)
Definition: scip_sol.c:1432
SCIP_Bool SCIPisPrimalboundSol(SCIP *scip)
SCIP_Longint SCIPgetNConflictDualproofsApplied(SCIP *scip)
SCIP_Longint SCIPgetNSolsFound(SCIP *scip)
SCIP_Real SCIPgetPrimalbound(SCIP *scip)
int SCIPgetMaxDepth(SCIP *scip)
SCIP_Real SCIPgetUpperbound(SCIP *scip)
SCIP_Longint SCIPgetNInfeasibleLeaves(SCIP *scip)
SCIP_Real SCIPgetGap(SCIP *scip)
SCIP_Longint SCIPgetNNodes(SCIP *scip)
SCIP_Real SCIPgetDualbound(SCIP *scip)
int SCIPgetNEnabledConss(SCIP *scip)
int SCIPgetNSepaRounds(SCIP *scip)
int SCIPgetNCutsApplied(SCIP *scip)
SCIP_Real SCIPgetLowerbound(SCIP *scip)
SCIP_Longint SCIPgetNTotalNodes(SCIP *scip)
SCIP_Real SCIPgetAvgDualbound(SCIP *scip)
SCIP_Longint SCIPgetNRootLPIterations(SCIP *scip)
SCIP_Real SCIPgetCutoffbound(SCIP *scip)
SCIP_Longint SCIPgetNConflictConssApplied(SCIP *scip)
SCIP_Longint SCIPgetNObjlimLeaves(SCIP *scip)
SCIP_Longint SCIPgetNStrongbranchs(SCIP *scip)
SCIP_Longint SCIPgetNLPIterations(SCIP *scip)
SCIP_Real SCIPgetSolvingTime(SCIP *scip)
Definition: scip_timing.c:378
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPepsilon(SCIP *scip)
int SCIPgetNNodesLeft(SCIP *scip)
Definition: scip_tree.c:644
int SCIPgetDepth(SCIP *scip)
Definition: scip_tree.c:670
int SCIPgetPlungeDepth(SCIP *scip)
Definition: scip_tree.c:713
interface methods for specific LP solvers
public methods for displaying runtime statistics
public methods for primal heuristics
public methods for message output
public methods for relaxation handlers
public methods for primal CIP solutions
public methods for branching rule plugins and branching
public methods for concurrent solving mode
public methods for cuts and aggregation rows
public methods for display handler plugins
general public methods
public methods for the LP relaxation, rows and columns
public methods for memory management
public methods for message handling
public methods for numerical tolerances
public methods for global and local (sub)problems
public methods for solutions
public methods for querying solving statistics
public methods for timing
public methods for the branch-and-bound tree
SCIP_Real SCIPsyncstoreGetLastUpperbound(SCIP_SYNCSTORE *syncstore)
Definition: syncstore.c:270
SCIP_Longint SCIPsyncstoreGetLastMemTotal(SCIP_SYNCSTORE *syncstore)
Definition: syncstore.c:314
int SCIPsyncstoreGetLastNSols(SCIP_SYNCSTORE *syncstore)
Definition: syncstore.c:292
the function declarations for the synchronization store
@ SCIP_DISPSTATUS_OFF
Definition: type_disp.h:60
@ SCIP_DISPSTATUS_AUTO
Definition: type_disp.h:61
struct SCIP_DispData SCIP_DISPDATA
Definition: type_disp.h:76
@ SCIP_DISPMODE_CONCURRENT
Definition: type_disp.h:70
@ SCIP_DISPMODE_ALL
Definition: type_disp.h:71
@ SCIP_LPSOLSTAT_NOTSOLVED
Definition: type_lp.h:42
@ SCIP_LPSOLSTAT_OPTIMAL
Definition: type_lp.h:43
type definitions for specific LP solvers interface
@ SCIP_LPSOLQUALITY_ESTIMCONDITION
Definition: type_lpi.h:101
@ SCIP_OKAY
Definition: type_retcode.h:42
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
@ SCIP_SOLTYPE_HEUR
Definition: type_sol.h:65
@ SCIP_SOLTYPE_STRONGBRANCH
Definition: type_sol.h:68
@ SCIP_SOLTYPE_RELAX
Definition: type_sol.h:66
@ SCIP_SOLTYPE_PSEUDO
Definition: type_sol.h:69
@ SCIP_SOLTYPE_LPRELAX
Definition: type_sol.h:67
@ SCIP_SOLTYPE_UNKNOWN
Definition: type_sol.h:64
@ SCIP_STATUS_INFORUNBD
Definition: type_stat.h:64