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