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