Scippy

GCG

Branch-and-Price & Column Generation for Everyone

disp_gcg.c
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the program */
4 /* GCG --- Generic Column Generation */
5 /* a Dantzig-Wolfe decomposition based extension */
6 /* of the branch-cut-and-price framework */
7 /* SCIP --- Solving Constraint Integer Programs */
8 /* */
9 /* Copyright (C) 2010-2021 Operations Research, RWTH Aachen University */
10 /* Zuse Institute Berlin (ZIB) */
11 /* */
12 /* This program is free software; you can redistribute it and/or */
13 /* modify it under the terms of the GNU Lesser General Public License */
14 /* as published by the Free Software Foundation; either version 3 */
15 /* of the License, or (at your option) any later version. */
16 /* */
17 /* This program is distributed in the hope that it will be useful, */
18 /* but WITHOUT ANY WARRANTY; without even the implied warranty of */
19 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
20 /* GNU Lesser General Public License for more details. */
21 /* */
22 /* You should have received a copy of the GNU Lesser General Public License */
23 /* along with this program; if not, write to the Free Software */
24 /* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.*/
25 /* */
26 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
27 
28 /**@file disp_gcg.c
29  * @ingroup DISPLAYS
30  * @brief GCG display columns
31  * @author Gerald Gamrath
32  * @author Christian Puchert
33  * @author Martin Bergner
34  */
35 
36 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
37 
38 #include <assert.h>
39 #include <string.h>
40 
41 #include "disp_gcg.h"
42 #include "scip/disp_default.h"
43 #include "gcg.h"
44 
45 #include "relax_gcg.h"
46 #include "pricer_gcg.h"
47 
48 #define DISP_NAME_SOLFOUND "solfound"
49 #define DISP_DESC_SOLFOUND "letter that indicates the heuristic, that found the solution"
50 #define DISP_HEAD_SOLFOUND " "
51 #define DISP_WIDT_SOLFOUND 2
52 #define DISP_PRIO_SOLFOUND 80000
53 #define DISP_POSI_SOLFOUND 0
54 #define DISP_STRI_SOLFOUND FALSE
55 
56 #define DISP_NAME_TIME "time"
57 #define DISP_DESC_TIME "total solution time"
58 #define DISP_HEAD_TIME "time"
59 #define DISP_WIDT_TIME 5
60 #define DISP_PRIO_TIME 4000
61 #define DISP_POSI_TIME 50
62 #define DISP_STRI_TIME TRUE
63 
64 #define DISP_NAME_NNODES "nnodes"
65 #define DISP_DESC_NNODES "number of processed nodes"
66 #define DISP_HEAD_NNODES "node"
67 #define DISP_WIDT_NNODES 7
68 #define DISP_PRIO_NNODES 100000
69 #define DISP_POSI_NNODES 100
70 #define DISP_STRI_NNODES TRUE
71 
72 #define DISP_NAME_NODESLEFT "nodesleft"
73 #define DISP_DESC_NODESLEFT "number of unprocessed nodes"
74 #define DISP_HEAD_NODESLEFT "left"
75 #define DISP_WIDT_NODESLEFT 7
76 #define DISP_PRIO_NODESLEFT 90000
77 #define DISP_POSI_NODESLEFT 200
78 #define DISP_STRI_NODESLEFT TRUE
79 
80 #define DISP_NAME_LPITERATIONS "lpiterations"
81 #define DISP_DESC_LPITERATIONS "number of simplex iterations"
82 #define DISP_HEAD_LPITERATIONS "LP iter"
83 #define DISP_WIDT_LPITERATIONS 7
84 #define DISP_PRIO_LPITERATIONS 1000
85 #define DISP_POSI_LPITERATIONS 1000
86 #define DISP_STRI_LPITERATIONS TRUE
87 
88 #define DISP_NAME_SLPITERATIONS "sumlpiterations"
89 #define DISP_DESC_SLPITERATIONS "number of simplex iterations in master and pricing problems"
90 #define DISP_HEAD_SLPITERATIONS "SLP iter"
91 #define DISP_WIDT_SLPITERATIONS 8
92 #define DISP_PRIO_SLPITERATIONS 30000
93 #define DISP_POSI_SLPITERATIONS 1050
94 #define DISP_STRI_SLPITERATIONS TRUE
95 
96 #define DISP_NAME_LPAVGITERS "lpavgiterations"
97 #define DISP_DESC_LPAVGITERS "average number of LP iterations since the last output line"
98 #define DISP_HEAD_LPAVGITERS "LP it/n"
99 #define DISP_WIDT_LPAVGITERS 7
100 #define DISP_PRIO_LPAVGITERS 25000
101 #define DISP_POSI_LPAVGITERS 1400
102 #define DISP_STRI_LPAVGITERS TRUE
103 
104 #define DISP_NAME_LPCOND "lpcond"
105 #define DISP_DESC_LPCOND "estimate on condition number of LP solution"
106 #define DISP_HEAD_LPCOND "LP cond"
107 #define DISP_WIDT_LPCOND 7
108 #define DISP_PRIO_LPCOND 0
109 #define DISP_POSI_LPCOND 1450
110 #define DISP_STRI_LPCOND TRUE
111 
112 #define DISP_NAME_MEMUSED "memused"
113 #define DISP_DESC_MEMUSED "total number of bytes used in block memory"
114 #define DISP_HEAD_MEMUSED "mem"
115 #define DISP_WIDT_MEMUSED 5
116 #define DISP_PRIO_MEMUSED 20000
117 #define DISP_POSI_MEMUSED 1500
118 #define DISP_STRI_MEMUSED TRUE
119 
120 #define DISP_NAME_DEPTH "depth"
121 #define DISP_DESC_DEPTH "depth of current node"
122 #define DISP_HEAD_DEPTH "depth"
123 #define DISP_WIDT_DEPTH 5
124 #define DISP_PRIO_DEPTH 500
125 #define DISP_POSI_DEPTH 2000
126 #define DISP_STRI_DEPTH TRUE
127 
128 #define DISP_NAME_MAXDEPTH "maxdepth"
129 #define DISP_DESC_MAXDEPTH "maximal depth of all processed nodes"
130 #define DISP_HEAD_MAXDEPTH "mdpt"
131 #define DISP_WIDT_MAXDEPTH 5
132 #define DISP_PRIO_MAXDEPTH 5000
133 #define DISP_POSI_MAXDEPTH 2100
134 #define DISP_STRI_MAXDEPTH TRUE
135 
136 #define DISP_NAME_PLUNGEDEPTH "plungedepth"
137 #define DISP_DESC_PLUNGEDEPTH "current plunging depth"
138 #define DISP_HEAD_PLUNGEDEPTH "pdpt"
139 #define DISP_WIDT_PLUNGEDEPTH 5
140 #define DISP_PRIO_PLUNGEDEPTH 10
141 #define DISP_POSI_PLUNGEDEPTH 2200
142 #define DISP_STRI_PLUNGEDEPTH TRUE
143 
144 #define DISP_NAME_NFRAC "nfrac"
145 #define DISP_DESC_NFRAC "number of fractional variables in the current solution"
146 #define DISP_HEAD_NFRAC "frac"
147 #define DISP_WIDT_NFRAC 5
148 #define DISP_PRIO_NFRAC 700
149 #define DISP_POSI_NFRAC 2500
150 #define DISP_STRI_NFRAC TRUE
151 
152 #define DISP_NAME_NEXTERNCANDS "nexternbranchcands"
153 #define DISP_DESC_NEXTERNCANDS "number of extern branching variables in the current node"
154 #define DISP_HEAD_NEXTERNCANDS "extbr"
155 #define DISP_WIDT_NEXTERNCANDS 5
156 #define DISP_PRIO_NEXTERNCANDS 650
157 #define DISP_POSI_NEXTERNCANDS 2600
158 #define DISP_STRI_NEXTERNCANDS TRUE
159 
160 #define DISP_NAME_VARS "vars"
161 #define DISP_DESC_VARS "number of variables in the original problem"
162 #define DISP_HEAD_VARS "ovars"
163 #define DISP_WIDT_VARS 5
164 #define DISP_PRIO_VARS 3000
165 #define DISP_POSI_VARS 3000
166 #define DISP_STRI_VARS TRUE
167 
168 #define DISP_NAME_CONSS "conss"
169 #define DISP_DESC_CONSS "number of globally valid constraints in the problem"
170 #define DISP_HEAD_CONSS "ocons"
171 #define DISP_WIDT_CONSS 5
172 #define DISP_PRIO_CONSS 3100
173 #define DISP_POSI_CONSS 3100
174 #define DISP_STRI_CONSS TRUE
175 
176 #define DISP_NAME_CURCONSS "curconss"
177 #define DISP_DESC_CURCONSS "number of enabled constraints in current node"
178 #define DISP_HEAD_CURCONSS "ccons"
179 #define DISP_WIDT_CURCONSS 5
180 #define DISP_PRIO_CURCONSS 600
181 #define DISP_POSI_CURCONSS 3200
182 #define DISP_STRI_CURCONSS TRUE
183 
184 #define DISP_NAME_CURCOLS "curcols"
185 #define DISP_DESC_CURCOLS "number of LP columns in current node"
186 #define DISP_HEAD_CURCOLS "cols"
187 #define DISP_WIDT_CURCOLS 5
188 #define DISP_PRIO_CURCOLS 800
189 #define DISP_POSI_CURCOLS 3300
190 #define DISP_STRI_CURCOLS TRUE
191 
192 #define DISP_NAME_CURROWS "currows"
193 #define DISP_DESC_CURROWS "number of LP rows in current node"
194 #define DISP_HEAD_CURROWS "rows"
195 #define DISP_WIDT_CURROWS 5
196 #define DISP_PRIO_CURROWS 900
197 #define DISP_POSI_CURROWS 3400
198 #define DISP_STRI_CURROWS TRUE
199 
200 #define DISP_NAME_CUTS "cuts"
201 #define DISP_DESC_CUTS "total number of cuts applied to the original LPs"
202 #define DISP_HEAD_CUTS "ocuts"
203 #define DISP_WIDT_CUTS 5
204 #define DISP_PRIO_CUTS 100
205 #define DISP_POSI_CUTS 3500
206 #define DISP_STRI_CUTS TRUE
207 
208 #define DISP_NAME_SEPAROUNDS "separounds"
209 #define DISP_DESC_SEPAROUNDS "number of separation rounds performed at the current node"
210 #define DISP_HEAD_SEPAROUNDS "sepa"
211 #define DISP_WIDT_SEPAROUNDS 4
212 #define DISP_PRIO_SEPAROUNDS 100
213 #define DISP_POSI_SEPAROUNDS 3600
214 #define DISP_STRI_SEPAROUNDS TRUE
215 
216 #define DISP_NAME_POOLSIZE "poolsize"
217 #define DISP_DESC_POOLSIZE "number of LP rows in the cut pool"
218 #define DISP_HEAD_POOLSIZE "pool"
219 #define DISP_WIDT_POOLSIZE 5
220 #define DISP_PRIO_POOLSIZE 50
221 #define DISP_POSI_POOLSIZE 3700
222 #define DISP_STRI_POOLSIZE TRUE
223 
224 #define DISP_NAME_CONFLICTS "conflicts"
225 #define DISP_DESC_CONFLICTS "total number of conflicts found in conflict analysis"
226 #define DISP_HEAD_CONFLICTS "confs"
227 #define DISP_WIDT_CONFLICTS 5
228 #define DISP_PRIO_CONFLICTS 2000
229 #define DISP_POSI_CONFLICTS 4000
230 #define DISP_STRI_CONFLICTS TRUE
231 
232 #define DISP_NAME_STRONGBRANCHS "strongbranchs"
233 #define DISP_DESC_STRONGBRANCHS "total number of strong branching calls"
234 #define DISP_HEAD_STRONGBRANCHS "strbr"
235 #define DISP_WIDT_STRONGBRANCHS 5
236 #define DISP_PRIO_STRONGBRANCHS 1000
237 #define DISP_POSI_STRONGBRANCHS 5000
238 #define DISP_STRI_STRONGBRANCHS TRUE
239 
240 #define DISP_NAME_PSEUDOOBJ "pseudoobj"
241 #define DISP_DESC_PSEUDOOBJ "current pseudo objective value"
242 #define DISP_HEAD_PSEUDOOBJ "pseudoobj"
243 #define DISP_WIDT_PSEUDOOBJ 14
244 #define DISP_PRIO_PSEUDOOBJ 300
245 #define DISP_POSI_PSEUDOOBJ 6000
246 #define DISP_STRI_PSEUDOOBJ TRUE
247 
248 #define DISP_NAME_LPOBJ "lpobj"
249 #define DISP_DESC_LPOBJ "current LP objective value"
250 #define DISP_HEAD_LPOBJ "lpobj"
251 #define DISP_WIDT_LPOBJ 14
252 #define DISP_PRIO_LPOBJ 300
253 #define DISP_POSI_LPOBJ 6500
254 #define DISP_STRI_LPOBJ TRUE
255 
256 #define DISP_NAME_CURDUALBOUND "curdualbound"
257 #define DISP_DESC_CURDUALBOUND "dual bound of current node"
258 #define DISP_HEAD_CURDUALBOUND "curdualbound"
259 #define DISP_WIDT_CURDUALBOUND 14
260 #define DISP_PRIO_CURDUALBOUND 400
261 #define DISP_POSI_CURDUALBOUND 7000
262 #define DISP_STRI_CURDUALBOUND TRUE
263 
264 #define DISP_NAME_ESTIMATE "estimate"
265 #define DISP_DESC_ESTIMATE "estimated value of feasible solution in current node"
266 #define DISP_HEAD_ESTIMATE "estimate"
267 #define DISP_WIDT_ESTIMATE 14
268 #define DISP_PRIO_ESTIMATE 200
269 #define DISP_POSI_ESTIMATE 7500
270 #define DISP_STRI_ESTIMATE TRUE
271 
272 #define DISP_NAME_AVGDUALBOUND "avgdualbound"
273 #define DISP_DESC_AVGDUALBOUND "average dual bound of all unprocessed nodes"
274 #define DISP_HEAD_AVGDUALBOUND "avgdualbound"
275 #define DISP_WIDT_AVGDUALBOUND 14
276 #define DISP_PRIO_AVGDUALBOUND 40
277 #define DISP_POSI_AVGDUALBOUND 8000
278 #define DISP_STRI_AVGDUALBOUND TRUE
279 
280 #define DISP_NAME_DUALBOUND "dualbound"
281 #define DISP_DESC_DUALBOUND "current global dual bound"
282 #define DISP_HEAD_DUALBOUND "dualbound"
283 #define DISP_WIDT_DUALBOUND 14
284 #define DISP_PRIO_DUALBOUND 70000
285 #define DISP_POSI_DUALBOUND 9000
286 #define DISP_STRI_DUALBOUND TRUE
287 
288 #define DISP_NAME_PRIMALBOUND "primalbound"
289 #define DISP_DESC_PRIMALBOUND "current primal bound"
290 #define DISP_HEAD_PRIMALBOUND "primalbound"
291 #define DISP_WIDT_PRIMALBOUND 14
292 #define DISP_PRIO_PRIMALBOUND 80000
293 #define DISP_POSI_PRIMALBOUND 10000
294 #define DISP_STRI_PRIMALBOUND TRUE
295 
296 #define DISP_NAME_CUTOFFBOUND "cutoffbound"
297 #define DISP_DESC_CUTOFFBOUND "current cutoff bound"
298 #define DISP_HEAD_CUTOFFBOUND "cutoffbound"
299 #define DISP_WIDT_CUTOFFBOUND 14
300 #define DISP_PRIO_CUTOFFBOUND 10
301 #define DISP_POSI_CUTOFFBOUND 10100
302 #define DISP_STRI_CUTOFFBOUND TRUE
303 
304 #define DISP_NAME_DEGENERACY "degeneracy"
305 #define DISP_DESC_DEGENERACY "current average degeneracy"
306 #define DISP_HEAD_DEGENERACY "deg"
307 #define DISP_WIDT_DEGENERACY 8
308 #define DISP_PRIO_DEGENERACY 40000
309 #define DISP_POSI_DEGENERACY 18000
310 #define DISP_STRI_DEGENERACY TRUE
311 
312 #define DISP_NAME_GAP "gap"
313 #define DISP_DESC_GAP "current (relative) gap using |primal-dual|/MIN(|dual|,|primal|)"
314 #define DISP_HEAD_GAP "gap"
315 #define DISP_WIDT_GAP 8
316 #define DISP_PRIO_GAP 60000
317 #define DISP_POSI_GAP 20000
318 #define DISP_STRI_GAP TRUE
319 
320 #define DISP_NAME_PRIMALGAP "primalgap"
321 #define DISP_DESC_PRIMALGAP "current (relative) gap using |primal-dual|/|primal|"
322 #define DISP_HEAD_PRIMALGAP "primgap"
323 #define DISP_WIDT_PRIMALGAP 8
324 #define DISP_PRIO_PRIMALGAP 20000
325 #define DISP_POSI_PRIMALGAP 21000
326 #define DISP_STRI_PRIMALGAP TRUE
327 
328 #define DISP_NAME_NSOLS "nsols"
329 #define DISP_DESC_NSOLS "current number of solutions found"
330 #define DISP_HEAD_NSOLS "nsols"
331 #define DISP_WIDT_NSOLS 5
332 #define DISP_PRIO_NSOLS 0
333 #define DISP_POSI_NSOLS 30000
334 #define DISP_STRI_NSOLS TRUE
335 
336 #define DISP_NAME_MLPITERATIONS "mlpiterations"
337 #define DISP_DESC_MLPITERATIONS "number of simplex iterations in the master"
338 #define DISP_HEAD_MLPITERATIONS "MLP iter"
339 #define DISP_WIDT_MLPITERATIONS 8
340 #define DISP_PRIO_MLPITERATIONS 80000
341 #define DISP_POSI_MLPITERATIONS 1100
342 #define DISP_STRI_MLPITERATIONS TRUE
343 
344 #define DISP_NAME_MVARS "mvars"
345 #define DISP_DESC_MVARS "number of variables in the master problem"
346 #define DISP_HEAD_MVARS "mvars"
347 #define DISP_WIDT_MVARS 5
348 #define DISP_PRIO_MVARS 70000
349 #define DISP_POSI_MVARS 3050
350 #define DISP_STRI_MVARS TRUE
351 
352 #define DISP_NAME_MCONSS "mconss"
353 #define DISP_DESC_MCONSS "number of globally valid constraints in the master problem"
354 #define DISP_HEAD_MCONSS "mcons"
355 #define DISP_WIDT_MCONSS 5
356 #define DISP_PRIO_MCONSS 70000
357 #define DISP_POSI_MCONSS 3150
358 #define DISP_STRI_MCONSS TRUE
359 
360 #define DISP_NAME_MCUTS "mcuts"
361 #define DISP_DESC_MCUTS "total number of cuts applied to the master LPs"
362 #define DISP_HEAD_MCUTS "mcuts"
363 #define DISP_WIDT_MCUTS 5
364 #define DISP_PRIO_MCUTS 80000
365 #define DISP_POSI_MCUTS 3550
366 #define DISP_STRI_MCUTS TRUE
367 
368 /*
369  * Callback methods
370  */
371 
372 /** copy method for display plugins (called when SCIP copies plugins) */
373 static
374 SCIP_DECL_DISPCOPY(dispCopyGcg)
375 { /*lint --e{715}*/
376  assert(scip != NULL);
377  assert(disp != NULL);
378 
379  /* call inclusion method of default SCIP display plugin */
380  SCIP_CALL( SCIPincludeDispDefault(scip) );
381 
382  return SCIP_OKAY;
383 }
384 
385 /** solving process initialization method of display column (called when branch and bound process is about to begin) */
386 static
387 SCIP_DECL_DISPINITSOL(SCIPdispInitsolSolFound)
388 { /*lint --e{715}*/
389 
390  assert(disp != NULL);
391  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_SOLFOUND) == 0);
392  assert(scip != NULL);
393 
394  SCIPdispSetData(disp, (SCIP_DISPDATA*)SCIPgetBestSol(scip));
395 
396  return SCIP_OKAY;
397 }
398 
399 /** output method of display column to output file stream 'file' for character of best solution */
400 static
401 SCIP_DECL_DISPOUTPUT(SCIPdispOutputSolFound)
402 { /*lint --e{715}*/
403  SCIP* masterprob;
404  SCIP_SOL* origsol;
405  SCIP_SOL* mastersol;
406  SCIP_DISPDATA* dispdata;
407 
408  assert(disp != NULL);
409  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_SOLFOUND) == 0);
410  assert(scip != NULL);
411 
412  /* get master problem */
413  masterprob = GCGgetMasterprob(scip);
414  assert(masterprob != NULL);
415 
416  origsol = SCIPgetBestSol(scip);
417  if( origsol == NULL )
418  SCIPdispSetData(disp, NULL);
419 
420  if( SCIPgetStage(masterprob) >= SCIP_STAGE_SOLVING )
421  mastersol = SCIPgetBestSol(masterprob);
422  else
423  mastersol = NULL;
424 
425  dispdata = SCIPdispGetData(disp);
426  if( origsol != (SCIP_SOL*)dispdata )
427  {
428  SCIPinfoMessage(scip, file, "%c", (SCIPgetSolHeur(scip, origsol) == NULL ? '*'
429  : SCIPheurGetDispchar(SCIPgetSolHeur(scip, origsol))));
430  /* If the solution was obtained in the master problem, display whether it came from its
431  * LP relaxation or from the master heuristics */
432  if( SCIPgetSolHeur(scip, origsol) == NULL && (mastersol != NULL) )
433  {
434  SCIPinfoMessage(scip, file, "%c", (SCIPgetSolHeur(masterprob, mastersol) == NULL ? '*'
435  : SCIPheurGetDispchar(SCIPgetSolHeur(masterprob, mastersol))));
436  }
437  else
438  {
439  SCIPinfoMessage(scip, file, " ");
440  }
441  SCIPdispSetData(disp, (SCIP_DISPDATA*)origsol);
442  }
443  else
444  SCIPinfoMessage(scip, file, " ");
445 
446  return SCIP_OKAY;
447 }
448 
449 /** output method of display column to output file stream 'file' for solving time */
450 static
451 SCIP_DECL_DISPOUTPUT(SCIPdispOutputSolvingTime)
452 { /*lint --e{715}*/
453  assert(disp != NULL);
454  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_TIME) == 0);
455  assert(scip != NULL);
456 
457  SCIPdispTime(SCIPgetMessagehdlr(scip), file, SCIPgetSolvingTime(scip), DISP_WIDT_TIME);
458 
459  return SCIP_OKAY;
460 }
461 
462 /** output method of display column to output file stream 'file' for number of nodes */
463 static
464 SCIP_DECL_DISPOUTPUT(SCIPdispOutputNNodes)
465 { /*lint --e{715}*/
466  SCIP* masterprob;
467 
468  assert(disp != NULL);
469  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_NNODES) == 0);
470  assert(scip != NULL);
471 
472  /* get master problem */
473  masterprob = GCGgetMasterprob(scip);
474  assert(masterprob != NULL);
475 
476  if( SCIPgetStage(masterprob) >= SCIP_STAGE_SOLVING && GCGgetDecompositionMode(scip) != DEC_DECMODE_DANTZIGWOLFE )
477  SCIPdispLongint(SCIPgetMessagehdlr(scip), file, SCIPgetNNodes(masterprob), DISP_WIDT_NNODES);
478  else
479  SCIPdispLongint(SCIPgetMessagehdlr(scip), file, SCIPgetNNodes(scip), DISP_WIDT_NNODES);
480 
481  return SCIP_OKAY;
482 }
483 
484 /** output method of display column to output file stream 'file' for number of open nodes */
485 static
486 SCIP_DECL_DISPOUTPUT(SCIPdispOutputNNodesLeft)
487 { /*lint --e{715}*/
488  SCIP* masterprob;
489 
490  assert(disp != NULL);
491  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_NODESLEFT) == 0);
492  assert(scip != NULL);
493 
494  /* get master problem */
495  masterprob = GCGgetMasterprob(scip);
496  assert(masterprob != NULL);
497 
498  if( SCIPgetStage(masterprob) >= SCIP_STAGE_SOLVING && GCGgetDecompositionMode(scip) != DEC_DECMODE_DANTZIGWOLFE )
499  SCIPdispInt(SCIPgetMessagehdlr(scip), file, SCIPgetNNodesLeft(masterprob), DISP_WIDT_NODESLEFT);
500  else
501  SCIPdispInt(SCIPgetMessagehdlr(scip), file, SCIPgetNNodesLeft(scip), DISP_WIDT_NODESLEFT);
502 
503  return SCIP_OKAY;
504 }
505 
506 /** output method of display column to output file stream 'file' for number of LP iterations */
507 static
508 SCIP_DECL_DISPOUTPUT(SCIPdispOutputNLPIterations)
509 { /*lint --e{715}*/
510  assert(disp != NULL);
511  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_LPITERATIONS) == 0);
512  assert(scip != NULL);
513 
514  SCIPdispLongint(SCIPgetMessagehdlr(scip), file, SCIPgetNLPIterations(scip), DISP_WIDT_LPITERATIONS);
515 
516  return SCIP_OKAY;
517 }
518 
519 /** output method of display column to output file stream 'file' for number of average LP iterations */
520 static
521 SCIP_DECL_DISPOUTPUT(SCIPdispOutputNLPAvgIters)
522 { /*lint --e{715}*/
523  SCIP* masterprob;
524  SCIP_Longint nnodes;
525 
526  assert(disp != NULL);
527  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_LPAVGITERS) == 0);
528  assert(scip != NULL);
529 
530  /**@todo Currently we are using the total number of nodes to compute the average LP iterations number. The reason for
531  * that is, that for the LP iterations only the total number (over all runs) are stored in the statistics. It
532  * would be nicer if the statistic also stores the number of LP iterations for the current run similar to the
533  * nodes.
534  */
535 
536  /* get master problem */
537  masterprob = GCGgetMasterprob(scip);
538  assert(masterprob != NULL);
539 
540  if( SCIPgetStage(masterprob) >= SCIP_STAGE_SOLVING && GCGgetDecompositionMode(scip) != DEC_DECMODE_DANTZIGWOLFE )
541  nnodes = SCIPgetNNodes(GCGgetMasterprob(scip));
542  else
543  nnodes = SCIPgetNNodes(scip);
544 
545  if( nnodes < 2 )
546  SCIPinfoMessage(scip, file, " - ");
547  else
548  SCIPinfoMessage(scip, file, "%6.1f ",
549  (SCIPgetNLPIterations(GCGgetMasterprob(scip)) - SCIPgetNRootLPIterations(GCGgetMasterprob(scip)))
550  / (SCIP_Real)(SCIPgetNNodes(GCGgetMasterprob(scip)) - 1) );
551 
552  return SCIP_OKAY;
553 }
554 
555 /** output method of display column to output file stream 'file' for estimate on LP condition */
556 static
557 SCIP_DECL_DISPOUTPUT(SCIPdispOutputLPCondition)
558 { /*lint --e{715}*/
559  SCIP_LPI* lpi;
560  SCIP_Real cond;
561 
562  assert(disp != NULL);
563  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_LPCOND) == 0);
564  assert(scip != NULL);
565 
566  SCIP_CALL( SCIPgetLPI(scip, &lpi) );
567  if( lpi == NULL )
568  {
569  SCIPinfoMessage(scip, file, " - ");
570  return SCIP_OKAY;
571  }
572 
573  SCIP_CALL( SCIPlpiGetRealSolQuality(lpi, SCIP_LPSOLQUALITY_ESTIMCONDITION, &cond) );
574 
575  if( cond == SCIP_INVALID ) /*lint !e777*/
576  SCIPinfoMessage(scip, file, " n/a ");
577  else
578  SCIPinfoMessage(scip, file, "%.1e", cond);
579 
580  return SCIP_OKAY;
581 }
582 
583 /** output method of display column to output file stream 'file' for depth */
584 static
585 SCIP_DECL_DISPOUTPUT(SCIPdispOutputDepth)
586 { /*lint --e{715}*/
587  assert(disp != NULL);
588  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_DEPTH) == 0);
589  assert(scip != NULL);
590 
591  SCIPdispInt(SCIPgetMessagehdlr(scip), file, SCIPgetDepth(scip), DISP_WIDT_DEPTH);
592 
593  return SCIP_OKAY;
594 }
595 
596 /** output method of display column to output file stream 'file' */
597 static
598 SCIP_DECL_DISPOUTPUT(SCIPdispOutputMemUsed)
599 { /*lint --e{715}*/
600  SCIP_Longint memused;
601  int i;
602 
603  assert(disp != NULL);
604  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_MEMUSED) == 0);
605  assert(scip != NULL);
606 
607  memused = SCIPgetMemUsed(scip);
608  memused += SCIPgetMemUsed(GCGgetMasterprob(scip));
609  for( i = 0; i < GCGgetNPricingprobs(scip); i++ )
610  {
611  memused += SCIPgetMemUsed(GCGgetPricingprob(scip, i));
612  }
613 
614  SCIPdispLongint(SCIPgetMessagehdlr(scip), file, memused, DISP_WIDT_MEMUSED);
615 
616  return SCIP_OKAY;
617 }
618 
619 /** output method of display column to output file stream 'file' for maximal depth */
620 static
621 SCIP_DECL_DISPOUTPUT(SCIPdispOutputMaxDepth)
622 { /*lint --e{715}*/
623  assert(disp != NULL);
624  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_MAXDEPTH) == 0);
625  assert(scip != NULL);
626 
627  SCIPdispInt(SCIPgetMessagehdlr(scip), file, SCIPgetMaxDepth(scip), DISP_WIDT_MAXDEPTH);
628 
629  return SCIP_OKAY;
630 }
631 
632 /** output method of display column to output file stream 'file' for plunging depth */
633 static
634 SCIP_DECL_DISPOUTPUT(SCIPdispOutputPlungeDepth)
635 { /*lint --e{715}*/
636  assert(disp != NULL);
637  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_PLUNGEDEPTH) == 0);
638  assert(scip != NULL);
639 
640  SCIPdispInt(SCIPgetMessagehdlr(scip), file, SCIPgetPlungeDepth(scip), DISP_WIDT_PLUNGEDEPTH);
641 
642  return SCIP_OKAY;
643 }
644 
645 /** output method of display column to output file stream 'file' for number of LP branch candidates */
646 static
647 SCIP_DECL_DISPOUTPUT(SCIPdispOutputNFrac)
648 { /*lint --e{715}*/
649  assert(disp != NULL);
650  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_NFRAC) == 0);
651  assert(scip != NULL);
652 
653  if( SCIPhasCurrentNodeLP(scip) && SCIPgetLPSolstat(scip) == SCIP_LPSOLSTAT_OPTIMAL )
654  SCIPdispInt(SCIPgetMessagehdlr(scip), file, SCIPgetNLPBranchCands(scip), DISP_WIDT_NFRAC);
655  else
656  SCIPinfoMessage(scip, file, " - ");
657 
658  return SCIP_OKAY;
659 }
660 
661 /** output method of display column to output file stream 'file' for number of external branch candidates */
662 static
663 SCIP_DECL_DISPOUTPUT(SCIPdispOutputNExternCands)
664 { /*lint --e{715}*/
665  assert(disp != NULL);
666  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_NEXTERNCANDS) == 0);
667  assert(scip != NULL);
668 
669  SCIPdispInt(SCIPgetMessagehdlr(scip), file, SCIPgetNExternBranchCands(scip), DISP_WIDT_NEXTERNCANDS);
670 
671  return SCIP_OKAY;
672 }
673 
674 /** output method of display column to output file stream 'file' for number of variables */
675 static
676 SCIP_DECL_DISPOUTPUT(SCIPdispOutputNVars)
677 { /*lint --e{715}*/
678  assert(disp != NULL);
679  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_VARS) == 0);
680  assert(scip != NULL);
681 
682  SCIPdispInt(SCIPgetMessagehdlr(scip), file, SCIPgetNVars(scip), DISP_WIDT_VARS);
683 
684  return SCIP_OKAY;
685 }
686 
687 /** output method of display column to output file stream 'file' for number of constraints */
688 static
689 SCIP_DECL_DISPOUTPUT(SCIPdispOutputNConss)
690 { /*lint --e{715}*/
691  assert(disp != NULL);
692  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_CONSS) == 0);
693  assert(scip != NULL);
694 
695  SCIPdispInt(SCIPgetMessagehdlr(scip), file, SCIPgetNConss(scip), DISP_WIDT_CONSS);
696 
697  return SCIP_OKAY;
698 }
699 
700 /** output method of display column to output file stream 'file' for number of enabled constraints */
701 static
702 SCIP_DECL_DISPOUTPUT(SCIPdispOutputNCurConss)
703 { /*lint --e{715}*/
704  assert(disp != NULL);
705  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_CURCONSS) == 0);
706  assert(scip != NULL);
707 
708  SCIPdispInt(SCIPgetMessagehdlr(scip), file, SCIPgetNEnabledConss(scip), DISP_WIDT_CURCONSS);
709 
710  return SCIP_OKAY;
711 }
712 
713 /** output method of display column to output file stream 'file' for number of columns in the LP */
714 static
715 SCIP_DECL_DISPOUTPUT(SCIPdispOutputNCurCols)
716 { /*lint --e{715}*/
717  assert(disp != NULL);
718  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_CURCOLS) == 0);
719  assert(scip != NULL);
720 
721  SCIPdispInt(SCIPgetMessagehdlr(scip), file, SCIPgetNLPCols(scip), DISP_WIDT_CURCOLS);
722 
723  return SCIP_OKAY;
724 }
725 
726 /** output method of display column to output file stream 'file' for number of rows in the LP */
727 static
728 SCIP_DECL_DISPOUTPUT(SCIPdispOutputNCurRows)
729 { /*lint --e{715}*/
730  assert(disp != NULL);
731  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_CURROWS) == 0);
732  assert(scip != NULL);
733 
734  SCIPdispInt(SCIPgetMessagehdlr(scip), file, SCIPgetNLPRows(scip), DISP_WIDT_CURROWS);
735 
736  return SCIP_OKAY;
737 }
738 
739 /** output method of display column to output file stream 'file' for number of applied cuts */
740 static
741 SCIP_DECL_DISPOUTPUT(SCIPdispOutputNAppliedCuts)
742 { /*lint --e{715}*/
743  assert(disp != NULL);
744  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_CUTS) == 0);
745  assert(scip != NULL);
746 
747  SCIPdispInt(SCIPgetMessagehdlr(scip), file, SCIPgetNCutsApplied(scip), DISP_WIDT_CUTS);
748 
749  return SCIP_OKAY;
750 }
751 
752 /** output method of display column to output file stream 'file' for number of separation rounds */
753 static
754 SCIP_DECL_DISPOUTPUT(SCIPdispOutputNSepaRounds)
755 { /*lint --e{715}*/
756  assert(disp != NULL);
757  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_SEPAROUNDS) == 0);
758  assert(scip != NULL);
759 
760  if( SCIPgetStage(GCGgetMasterprob(scip)) == SCIP_STAGE_SOLVING )
761  {
762  SCIPdispInt(SCIPgetMessagehdlr(scip), file, SCIPgetNSepaRounds(GCGgetMasterprob(scip)), DISP_WIDT_SEPAROUNDS);
763  }
764  else
765  {
766  SCIPdispInt(SCIPgetMessagehdlr(scip), file, 0, DISP_WIDT_SEPAROUNDS);
767  }
768 
769  return SCIP_OKAY;
770 }
771 
772 /** output method of display column to output file stream 'file' for number of current rows in the cut pool */
773 static
774 SCIP_DECL_DISPOUTPUT(SCIPdispOutputCutPoolSize)
775 { /*lint --e{715}*/
776  assert(disp != NULL);
777  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_POOLSIZE) == 0);
778  assert(scip != NULL);
779 
780  if( SCIPgetStage(GCGgetMasterprob(scip)) >= SCIP_STAGE_SOLVING )
781  {
782  SCIPdispInt(SCIPgetMessagehdlr(scip), file, SCIPgetNPoolCuts(GCGgetMasterprob(scip)), DISP_WIDT_POOLSIZE);
783  }
784  else
785  {
786  SCIPdispInt(SCIPgetMessagehdlr(scip), file, 0, DISP_WIDT_POOLSIZE);
787  }
788 
789  return SCIP_OKAY;
790 }
791 
792 /** output method of display column to output file stream 'file' for number of conflicts */
793 static
794 SCIP_DECL_DISPOUTPUT(SCIPdispOutputNConflicts)
795 { /*lint --e{715}*/
796  assert(disp != NULL);
797  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_CONFLICTS) == 0);
798  assert(scip != NULL);
799 
800  SCIPdispLongint(SCIPgetMessagehdlr(scip), file, SCIPgetNConflictConssApplied(scip), DISP_WIDT_CONFLICTS);
801 
802  return SCIP_OKAY;
803 }
804 
805 /** output method of display column to output file stream 'file' for number of strong branchings */
806 static
807 SCIP_DECL_DISPOUTPUT(SCIPdispOutputNStrongbranchs)
808 { /*lint --e{715}*/
809  assert(disp != NULL);
810  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_STRONGBRANCHS) == 0);
811  assert(scip != NULL);
812 
813  SCIPdispLongint(SCIPgetMessagehdlr(scip), file, SCIPgetNStrongbranchs(scip), DISP_WIDT_STRONGBRANCHS);
814 
815  return SCIP_OKAY;
816 }
817 
818 /** output method of display column to output file stream 'file' for pseudo objective value */
819 static
820 SCIP_DECL_DISPOUTPUT(SCIPdispOutputPseudoObjval)
821 { /*lint --e{715}*/
822  SCIP_Real pseudoobj;
823 
824  assert(disp != NULL);
825  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_PSEUDOOBJ) == 0);
826  assert(scip != NULL);
827 
828  pseudoobj = SCIPgetPseudoObjval(scip);
829 
830  if( SCIPisInfinity(scip, -pseudoobj) )
831  SCIPinfoMessage(scip, file, " -- ");
832  else if( SCIPisInfinity(scip, pseudoobj) )
833  SCIPinfoMessage(scip, file, " cutoff ");
834  else
835  SCIPinfoMessage(scip, file, "%13.6e ", pseudoobj);
836 
837  return SCIP_OKAY;
838 }
839 
840 /** output method of display column to output file stream 'file' for LP objective value */
841 static
842 SCIP_DECL_DISPOUTPUT(SCIPdispOutputLPObjval)
843 { /*lint --e{715}*/
844 
845  assert(disp != NULL);
846  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_LPOBJ) == 0);
847  assert(scip != NULL);
848 
849  if( SCIPgetStage(GCGgetMasterprob(scip)) != SCIP_STAGE_SOLVING || SCIPgetLPSolstat(GCGgetMasterprob(scip)) == SCIP_LPSOLSTAT_NOTSOLVED )
850  {
851  SCIPinfoMessage(scip, file, " -- ");
852  }
853  else
854  {
855  SCIP_Real lpobj = SCIPgetLPObjval(GCGgetMasterprob(scip));
856  if( SCIPisInfinity(scip, -lpobj) )
857  SCIPinfoMessage(scip, file, " -- ");
858  else if( SCIPisInfinity(scip, lpobj) )
859  SCIPinfoMessage(scip, file, " cutoff ");
860  else
861  SCIPinfoMessage(scip, file, "%13.6e ", lpobj);
862  }
863 
864  return SCIP_OKAY;
865 }
866 
867 /** output method of display column to output file stream 'file' for the current dualbound */
868 static
869 SCIP_DECL_DISPOUTPUT(SCIPdispOutputCurDualbound)
870 { /*lint --e{715}*/
871  SCIP_Real curdualbound;
872 
873  assert(disp != NULL);
874  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_CURDUALBOUND) == 0);
875  assert(scip != NULL);
876 
877  curdualbound = SCIPgetLocalDualbound(scip);
878 
879  if( SCIPisInfinity(scip, (SCIP_Real) SCIPgetObjsense(scip) * curdualbound ) )
880  SCIPinfoMessage(scip, file, " cutoff ");
881  else if( SCIPisInfinity(scip, -1.0 * (SCIP_Real) SCIPgetObjsense(scip) * curdualbound ) )
882  SCIPinfoMessage(scip, file, " -- ");
883  else
884  SCIPinfoMessage(scip, file, "%13.6e ", curdualbound);
885 
886  return SCIP_OKAY;
887 }
888 
889 /** output method of display column to output file stream 'file' for estimate of best primal solution w.r.t. original
890  * problem contained in current subtree */
891 static
892 SCIP_DECL_DISPOUTPUT(SCIPdispOutputLocalOrigEstimate)
893 { /*lint --e{715}*/
894  SCIP_Real estimate;
895 
896  assert(disp != NULL);
897  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_ESTIMATE) == 0);
898  assert(scip != NULL);
899 
900  estimate = SCIPgetLocalOrigEstimate(scip);
901  if( SCIPisInfinity(scip, REALABS(estimate)) )
902  SCIPinfoMessage(scip, file, " -- ");
903  else
904  SCIPinfoMessage(scip, file, "%13.6e ", estimate);
905 
906  return SCIP_OKAY;
907 }
908 
909 /** output method of display column to output file stream 'file' for average dualbound */
910 static
911 SCIP_DECL_DISPOUTPUT(SCIPdispOutputAvgDualbound)
912 { /*lint --e{715}*/
913  SCIP_Real avgdualbound;
914 
915  assert(disp != NULL);
916  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_AVGDUALBOUND) == 0);
917  assert(scip != NULL);
918 
919  avgdualbound = SCIPgetAvgDualbound(scip);
920  if( SCIPisInfinity(scip, REALABS(avgdualbound)) )
921  SCIPinfoMessage(scip, file, " -- ");
922  else
923  SCIPinfoMessage(scip, file, "%13.6e ", avgdualbound);
924 
925  return SCIP_OKAY;
926 }
927 
928 /** output method of display column to output file stream 'file' for dualbound */
929 static
930 SCIP_DECL_DISPOUTPUT(SCIPdispOutputDualbound)
931 { /*lint --e{715}*/
932  SCIP_Real dualbound;
933 
934  assert(disp != NULL);
935  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_DUALBOUND) == 0);
936  assert(scip != NULL);
937 
938  dualbound = GCGgetDualbound(scip);
939 
940  if( SCIPisInfinity(scip, (SCIP_Real) SCIPgetObjsense(scip) * dualbound ) )
941  SCIPinfoMessage(scip, file, " cutoff ");
942  else if( SCIPisInfinity(scip, -1.0 * (SCIP_Real) SCIPgetObjsense(scip) * dualbound ) )
943  SCIPinfoMessage(scip, file, " -- ");
944  else
945  SCIPinfoMessage(scip, file, "%13.6e ", dualbound);
946 
947  return SCIP_OKAY;
948 }
949 
950 /** output method of display column to output file stream 'file' for primalbound */
951 static
952 SCIP_DECL_DISPOUTPUT(SCIPdispOutputPrimalbound)
953 { /*lint --e{715}*/
954  SCIP_Real primalbound;
955 
956  assert(disp != NULL);
957  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_PRIMALBOUND) == 0);
958  assert(scip != NULL);
959 
960  primalbound = GCGgetPrimalbound(scip);
961 
962  if( SCIPisInfinity(scip, REALABS(primalbound)) )
963  SCIPinfoMessage(scip, file, " -- ");
964  else
965  SCIPinfoMessage(scip, file, "%13.6e%c", primalbound, SCIPisPrimalboundSol(scip) ? ' ' : '*');
966 
967  return SCIP_OKAY;
968 }
969 
970 /** output method of display column to output file stream 'file' for cutoffbound */
971 static
972 SCIP_DECL_DISPOUTPUT(SCIPdispOutputCutoffbound)
973 { /*lint --e{715}*/
974  SCIP_Real cutoffbound;
975 
976  assert(disp != NULL);
977  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_CUTOFFBOUND) == 0);
978  assert(scip != NULL);
979 
980  cutoffbound = SCIPgetCutoffbound(scip);
981  if( SCIPisInfinity(scip, REALABS(cutoffbound)) )
982  SCIPinfoMessage(scip, file, " -- ");
983  else
984  SCIPinfoMessage(scip, file, "%13.6e ", SCIPretransformObj(scip, cutoffbound));
985 
986  return SCIP_OKAY;
987 }
988 
989 /** output method of display column to output file stream 'file' for gap */
990 static
991 SCIP_DECL_DISPOUTPUT(SCIPdispOutputGap)
992 { /*lint --e{715}*/
993  SCIP_Real gap;
994 
995  assert(disp != NULL);
996  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_GAP) == 0);
997  assert(scip != NULL);
998 
999  gap = GCGgetGap(scip);
1000 
1001  if( SCIPisInfinity(scip, gap) )
1002  SCIPinfoMessage(scip, file, " Inf ");
1003  else if( gap >= 100.00 )
1004  SCIPinfoMessage(scip, file, " Large ");
1005  else
1006  SCIPinfoMessage(scip, file, "%7.2f%%", 100.0*gap);
1007 
1008  return SCIP_OKAY;
1009 }
1010 
1011 /** output method of display column to output file stream 'file' for the sum of simplex iterations */
1012 static
1013 SCIP_DECL_DISPOUTPUT(SCIPdispOutputSlpiterations)
1014 { /*lint --e{715}*/
1015 
1016  SCIP* masterprob;
1017 
1018  assert(disp != NULL);
1019  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_SLPITERATIONS) == 0);
1020  assert(scip != NULL);
1021 
1022  masterprob = GCGgetMasterprob(scip);
1023 
1024  if( masterprob != NULL && SCIPgetStage(masterprob) >= SCIP_STAGE_SOLVING )
1025  {
1026  SCIPdispLongint(SCIPgetMessagehdlr(scip), file, SCIPgetNLPIterations(masterprob) + GCGmasterGetPricingSimplexIters(masterprob), DISP_WIDT_SLPITERATIONS);
1027  }
1028  else
1029  {
1030  SCIPdispLongint(SCIPgetMessagehdlr(scip), file, 0LL, DISP_WIDT_SLPITERATIONS);
1031  }
1032 
1033  return SCIP_OKAY;
1034 }
1035 
1036 
1037 /** output method of display column to output file stream 'file' for degeneracy */
1038 static
1039 SCIP_DECL_DISPOUTPUT(SCIPdispOutputDegeneracy)
1040 { /*lint --e{715}*/
1041  SCIP_Real degeneracy;
1042 
1043  assert(disp != NULL);
1044  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_DEGENERACY) == 0);
1045  assert(scip != NULL);
1046 
1047  degeneracy = GCGgetDegeneracy(scip);
1048 
1049  if( SCIPisInfinity(scip, degeneracy) )
1050  SCIPinfoMessage(scip, file, " -- ");
1051  else
1052  SCIPinfoMessage(scip, file, "%7.2f%%", 100.0*degeneracy);
1053 
1054  return SCIP_OKAY;
1055 }
1056 
1057 
1058 /** output method of display column to output file stream 'file' for primalgap */
1059 static
1060 SCIP_DECL_DISPOUTPUT(SCIPdispOutputPrimalgap)
1061 { /*lint --e{715}*/
1062  SCIP_Real primalbound;
1063  SCIP_Real dualbound;
1064  SCIP_Real gap;
1065 
1066  assert(disp != NULL);
1067  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_PRIMALGAP) == 0);
1068  assert(scip != NULL);
1069 
1070  primalbound = SCIPgetPrimalbound(scip);
1071  dualbound = SCIPgetDualbound(scip);
1072 
1073  if( SCIPisEQ(scip, primalbound, dualbound) )
1074  gap = 0.0;
1075  else if( SCIPisZero(scip, primalbound) || SCIPisInfinity(scip, REALABS(primalbound)) || primalbound * dualbound < 0.0 )
1076  gap = SCIPinfinity(scip);
1077  else
1078  gap = REALABS((primalbound - dualbound))/REALABS(primalbound + SCIPepsilon(scip));
1079 
1080  if( SCIPisInfinity(scip, gap) )
1081  SCIPinfoMessage(scip, file, " Inf ");
1082  else if( gap >= 100.00 )
1083  SCIPinfoMessage(scip, file, " Large ");
1084  else
1085  SCIPinfoMessage(scip, file, "%7.2f%%", 100.0*gap);
1086 
1087  return SCIP_OKAY;
1088 }
1089 
1090 /** output method of display column to output file stream 'file' for number of found solutions */
1091 static
1092 SCIP_DECL_DISPOUTPUT(SCIPdispOutputNSols)
1093 { /*lint --e{715}*/
1094  SCIPinfoMessage(scip, file, "%5"SCIP_LONGINT_FORMAT, SCIPgetNSolsFound(scip));
1095 
1096  return SCIP_OKAY;
1097 }
1098 
1099 /** output method of display column to output file stream 'file' */
1100 static
1101 SCIP_DECL_DISPOUTPUT(SCIPdispOutputMlpiterations)
1102 { /*lint --e{715}*/
1103  assert(disp != NULL);
1104  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_MLPITERATIONS) == 0);
1105  assert(scip != NULL);
1106 
1107  if( SCIPgetStage(GCGgetMasterprob(scip)) >= SCIP_STAGE_SOLVING )
1108  {
1109  SCIPdispLongint(SCIPgetMessagehdlr(scip), file, SCIPgetNLPIterations(GCGgetMasterprob(scip)), DISP_WIDT_MLPITERATIONS);
1110  }
1111  else
1112  {
1113  SCIPdispLongint(SCIPgetMessagehdlr(scip), file, 0LL, DISP_WIDT_MLPITERATIONS);
1114  }
1115 
1116  return SCIP_OKAY;
1117 }
1118 
1119 /** output method of display column to output file stream 'file' */
1120 static
1121 SCIP_DECL_DISPOUTPUT(SCIPdispOutputMvars)
1122 { /*lint --e{715}*/
1123  assert(disp != NULL);
1124  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_MVARS) == 0);
1125  assert(scip != NULL);
1126 
1127  if( SCIPgetStage(GCGgetMasterprob(scip)) >= SCIP_STAGE_SOLVING )
1128  {
1129  SCIPdispInt(SCIPgetMessagehdlr(scip), file, SCIPgetNVars(GCGgetMasterprob(scip)), DISP_WIDT_MVARS);
1130  }
1131  else
1132  {
1133  SCIPdispInt(SCIPgetMessagehdlr(scip), file, 0, DISP_WIDT_MVARS);
1134  }
1135 
1136  return SCIP_OKAY;
1137 }
1138 
1139 /** output method of display column to output file stream 'file' */
1140 static
1141 SCIP_DECL_DISPOUTPUT(SCIPdispOutputMconss)
1142 { /*lint --e{715}*/
1143  assert(disp != NULL);
1144  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_MCONSS) == 0);
1145  assert(scip != NULL);
1146 
1147  if( SCIPgetStage(GCGgetMasterprob(scip)) >= SCIP_STAGE_SOLVING )
1148  {
1149  SCIPdispInt(SCIPgetMessagehdlr(scip), file, SCIPgetNConss(GCGgetMasterprob(scip)), DISP_WIDT_MCONSS);
1150  }
1151  else
1152  {
1153  SCIPdispInt(SCIPgetMessagehdlr(scip), file, 0, DISP_WIDT_MCONSS);
1154  }
1155 
1156  return SCIP_OKAY;
1157 }
1158 
1159 /** output method of display column to output file stream 'file' */
1160 static
1161 SCIP_DECL_DISPOUTPUT(SCIPdispOutputMcuts)
1162 { /*lint --e{715}*/
1163  assert(disp != NULL);
1164  assert(strcmp(SCIPdispGetName(disp), DISP_NAME_MCUTS) == 0);
1165  assert(scip != NULL);
1166 
1167  if( SCIPgetStage(GCGgetMasterprob(scip)) >= SCIP_STAGE_SOLVING )
1168  {
1169  SCIPdispInt(SCIPgetMessagehdlr(scip), file, SCIPgetNCutsApplied(GCGgetMasterprob(scip)), DISP_WIDT_MCUTS);
1170  }
1171  else
1172  {
1173  SCIPdispInt(SCIPgetMessagehdlr(scip), file, 0, DISP_WIDT_MCUTS);
1174  }
1175 
1176 
1177 
1178  return SCIP_OKAY;
1179 }
1180 
1181 /*
1182  * default display columns specific interface methods
1183  */
1184 
1185 /** includes the default display columns in SCIP */
1186 SCIP_RETCODE SCIPincludeDispGcg(
1187  SCIP* scip /**< SCIP data structure */
1188  )
1189 {
1190  SCIP_DISP* tmpdisp;
1191 
1192  tmpdisp = SCIPfindDisp(scip, DISP_NAME_SOLFOUND);
1193  if( tmpdisp == NULL )
1194  {
1195  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_SOLFOUND, DISP_DESC_SOLFOUND, DISP_HEAD_SOLFOUND,
1196  SCIP_DISPSTATUS_AUTO,
1197  dispCopyGcg,
1198  NULL, NULL, NULL, SCIPdispInitsolSolFound, NULL, SCIPdispOutputSolFound, NULL,
1200  }
1201  tmpdisp = SCIPfindDisp(scip, DISP_NAME_TIME);
1202  if( tmpdisp == NULL )
1203  {
1204  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_TIME, DISP_DESC_TIME, DISP_HEAD_TIME,
1205  SCIP_DISPSTATUS_AUTO,
1206  dispCopyGcg,
1207  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputSolvingTime, NULL,
1209  }
1210  tmpdisp = SCIPfindDisp(scip, DISP_NAME_NNODES);
1211  if( tmpdisp == NULL )
1212  {
1213  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_NNODES, DISP_DESC_NNODES, DISP_HEAD_NNODES,
1214  SCIP_DISPSTATUS_AUTO,
1215  dispCopyGcg,
1216  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNNodes, NULL,
1218  }
1219  tmpdisp = SCIPfindDisp(scip, DISP_NAME_NODESLEFT);
1220  if( tmpdisp == NULL )
1221  {
1222  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_NODESLEFT, DISP_DESC_NODESLEFT, DISP_HEAD_NODESLEFT,
1223  SCIP_DISPSTATUS_AUTO,
1224  dispCopyGcg,
1225  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNNodesLeft, NULL,
1227  }
1228  tmpdisp = SCIPfindDisp(scip, DISP_NAME_LPITERATIONS);
1229  if( tmpdisp == NULL )
1230  {
1231  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_LPITERATIONS, DISP_DESC_LPITERATIONS, DISP_HEAD_LPITERATIONS,
1232  SCIP_DISPSTATUS_AUTO,
1233  dispCopyGcg,
1234  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNLPIterations, NULL,
1236  }
1237  tmpdisp = SCIPfindDisp(scip, DISP_NAME_LPAVGITERS);
1238  if( tmpdisp == NULL )
1239  {
1240  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_LPAVGITERS, DISP_DESC_LPAVGITERS, DISP_HEAD_LPAVGITERS,
1241  SCIP_DISPSTATUS_AUTO,
1242  dispCopyGcg,
1243  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNLPAvgIters, NULL,
1245  }
1246  tmpdisp = SCIPfindDisp(scip, DISP_NAME_LPCOND);
1247  if( tmpdisp == NULL )
1248  {
1249  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_LPCOND, DISP_DESC_LPCOND, DISP_HEAD_LPCOND,
1250  SCIP_DISPSTATUS_AUTO,
1251  dispCopyGcg,
1252  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputLPCondition, NULL,
1254  }
1255  tmpdisp = SCIPfindDisp(scip, DISP_NAME_MEMUSED);
1256  if( tmpdisp == NULL )
1257  {
1258  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_MEMUSED, DISP_DESC_MEMUSED, DISP_HEAD_MEMUSED,
1259  SCIP_DISPSTATUS_AUTO,
1260  dispCopyGcg,
1261  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputMemUsed, NULL,
1263  }
1264  tmpdisp = SCIPfindDisp(scip, DISP_NAME_DEPTH);
1265  if( tmpdisp == NULL )
1266  {
1267  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_DEPTH, DISP_DESC_DEPTH, DISP_HEAD_DEPTH,
1268  SCIP_DISPSTATUS_AUTO,
1269  dispCopyGcg,
1270  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputDepth, NULL,
1272  }
1273  tmpdisp = SCIPfindDisp(scip, DISP_NAME_MAXDEPTH);
1274  if( tmpdisp == NULL )
1275  {
1276  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_MAXDEPTH, DISP_DESC_MAXDEPTH, DISP_HEAD_MAXDEPTH,
1277  SCIP_DISPSTATUS_AUTO,
1278  dispCopyGcg,
1279  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputMaxDepth, NULL,
1281  }
1282  tmpdisp = SCIPfindDisp(scip, DISP_NAME_PLUNGEDEPTH);
1283  if( tmpdisp == NULL )
1284  {
1285  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_PLUNGEDEPTH, DISP_DESC_PLUNGEDEPTH, DISP_HEAD_PLUNGEDEPTH,
1286  SCIP_DISPSTATUS_AUTO,
1287  dispCopyGcg,
1288  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputPlungeDepth, NULL,
1290  }
1291  tmpdisp = SCIPfindDisp(scip, DISP_NAME_NFRAC);
1292  if( tmpdisp == NULL )
1293  {
1294  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_NFRAC, DISP_DESC_NFRAC, DISP_HEAD_NFRAC,
1295  SCIP_DISPSTATUS_AUTO,
1296  dispCopyGcg,
1297  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNFrac, NULL,
1299  }
1300  tmpdisp = SCIPfindDisp(scip, DISP_NAME_NEXTERNCANDS);
1301  if( tmpdisp == NULL )
1302  {
1303  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_NEXTERNCANDS, DISP_DESC_NEXTERNCANDS, DISP_HEAD_NEXTERNCANDS,
1304  SCIP_DISPSTATUS_AUTO,
1305  dispCopyGcg,
1306  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNExternCands, NULL,
1308  }
1309  tmpdisp = SCIPfindDisp(scip, DISP_NAME_VARS);
1310  if( tmpdisp == NULL )
1311  {
1312  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_VARS, DISP_DESC_VARS, DISP_HEAD_VARS,
1313  SCIP_DISPSTATUS_AUTO,
1314  dispCopyGcg,
1315  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNVars, NULL,
1317  }
1318  tmpdisp = SCIPfindDisp(scip, DISP_NAME_CONSS);
1319  if( tmpdisp == NULL )
1320  {
1321  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_CONSS, DISP_DESC_CONSS, DISP_HEAD_CONSS,
1322  SCIP_DISPSTATUS_AUTO,
1323  dispCopyGcg,
1324  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNConss, NULL,
1326  }
1327  tmpdisp = SCIPfindDisp(scip, DISP_NAME_CURCONSS);
1328  if( tmpdisp == NULL )
1329  {
1330  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_CURCONSS, DISP_DESC_CURCONSS, DISP_HEAD_CURCONSS,
1331  SCIP_DISPSTATUS_AUTO,
1332  dispCopyGcg,
1333  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNCurConss, NULL,
1335  }
1336  tmpdisp = SCIPfindDisp(scip, DISP_NAME_CURCOLS);
1337  if( tmpdisp == NULL )
1338  {
1339  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_CURCOLS, DISP_DESC_CURCOLS, DISP_HEAD_CURCOLS,
1340  SCIP_DISPSTATUS_AUTO,
1341  dispCopyGcg,
1342  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNCurCols, NULL,
1344  }
1345  tmpdisp = SCIPfindDisp(scip, DISP_NAME_CURROWS);
1346  if( tmpdisp == NULL )
1347  {
1348  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_CURROWS, DISP_DESC_CURROWS, DISP_HEAD_CURROWS,
1349  SCIP_DISPSTATUS_AUTO,
1350  dispCopyGcg,
1351  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNCurRows, NULL,
1353  }
1354  tmpdisp = SCIPfindDisp(scip, DISP_NAME_CUTS);
1355  if( tmpdisp == NULL )
1356  {
1357  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_CUTS, DISP_DESC_CUTS, DISP_HEAD_CUTS,
1358  SCIP_DISPSTATUS_AUTO,
1359  dispCopyGcg,
1360  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNAppliedCuts, NULL,
1362  }
1363  tmpdisp = SCIPfindDisp(scip, DISP_NAME_SEPAROUNDS);
1364  if( tmpdisp == NULL )
1365  {
1366  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_SEPAROUNDS, DISP_DESC_SEPAROUNDS, DISP_HEAD_SEPAROUNDS,
1367  SCIP_DISPSTATUS_AUTO,
1368  dispCopyGcg,
1369  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNSepaRounds, NULL,
1371  }
1372  tmpdisp = SCIPfindDisp(scip, DISP_NAME_POOLSIZE);
1373  if( tmpdisp == NULL )
1374  {
1375  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_POOLSIZE, DISP_DESC_POOLSIZE, DISP_HEAD_POOLSIZE,
1376  SCIP_DISPSTATUS_AUTO,
1377  dispCopyGcg,
1378  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputCutPoolSize, NULL,
1380  }
1381  tmpdisp = SCIPfindDisp(scip,DISP_NAME_CONFLICTS);
1382  if( tmpdisp == NULL )
1383  {
1384  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_CONFLICTS, DISP_DESC_CONFLICTS, DISP_HEAD_CONFLICTS,
1385  SCIP_DISPSTATUS_AUTO,
1386  dispCopyGcg,
1387  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNConflicts, NULL,
1389  }
1390  tmpdisp = SCIPfindDisp(scip, DISP_NAME_STRONGBRANCHS);
1391  if( tmpdisp == NULL )
1392  {
1393  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_STRONGBRANCHS, DISP_DESC_STRONGBRANCHS, DISP_HEAD_STRONGBRANCHS,
1394  SCIP_DISPSTATUS_AUTO,
1395  dispCopyGcg,
1396  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNStrongbranchs, NULL,
1398  }
1399  tmpdisp = SCIPfindDisp(scip, DISP_NAME_PSEUDOOBJ);
1400  if( tmpdisp == NULL )
1401  {
1402  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_PSEUDOOBJ, DISP_DESC_PSEUDOOBJ, DISP_HEAD_PSEUDOOBJ,
1403  SCIP_DISPSTATUS_AUTO,
1404  dispCopyGcg,
1405  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputPseudoObjval, NULL,
1407  }
1408  tmpdisp = SCIPfindDisp(scip, DISP_NAME_LPOBJ);
1409  if( tmpdisp == NULL )
1410  {
1411  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_LPOBJ, DISP_DESC_LPOBJ, DISP_HEAD_LPOBJ,
1412  SCIP_DISPSTATUS_AUTO,
1413  dispCopyGcg,
1414  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputLPObjval, NULL,
1416  }
1417  tmpdisp = SCIPfindDisp(scip, DISP_NAME_CURDUALBOUND);
1418  if( tmpdisp == NULL )
1419  {
1420  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_CURDUALBOUND, DISP_DESC_CURDUALBOUND, DISP_HEAD_CURDUALBOUND,
1421  SCIP_DISPSTATUS_AUTO,
1422  dispCopyGcg,
1423  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputCurDualbound, NULL,
1425  }
1426  tmpdisp = SCIPfindDisp(scip, DISP_NAME_ESTIMATE);
1427  if( tmpdisp == NULL )
1428  {
1429  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_ESTIMATE, DISP_DESC_ESTIMATE, DISP_HEAD_ESTIMATE,
1430  SCIP_DISPSTATUS_AUTO,
1431  dispCopyGcg,
1432  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputLocalOrigEstimate, NULL,
1434  }
1435  tmpdisp = SCIPfindDisp(scip, DISP_NAME_AVGDUALBOUND);
1436  if( tmpdisp == NULL )
1437  {
1438  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_AVGDUALBOUND, DISP_DESC_AVGDUALBOUND, DISP_HEAD_AVGDUALBOUND,
1439  SCIP_DISPSTATUS_AUTO,
1440  dispCopyGcg,
1441  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputAvgDualbound, NULL,
1443  }
1444  tmpdisp = SCIPfindDisp(scip, DISP_NAME_DUALBOUND);
1445  if( tmpdisp == NULL )
1446  {
1447  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_DUALBOUND, DISP_DESC_DUALBOUND, DISP_HEAD_DUALBOUND,
1448  SCIP_DISPSTATUS_AUTO,
1449  dispCopyGcg,
1450  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputDualbound, NULL,
1452  }
1453  tmpdisp = SCIPfindDisp(scip, DISP_NAME_PRIMALBOUND);
1454  if( tmpdisp == NULL )
1455  {
1456  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_PRIMALBOUND, DISP_DESC_PRIMALBOUND, DISP_HEAD_PRIMALBOUND,
1457  SCIP_DISPSTATUS_AUTO,
1458  dispCopyGcg,
1459  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputPrimalbound, NULL,
1461  }
1462  tmpdisp = SCIPfindDisp(scip, DISP_NAME_CUTOFFBOUND);
1463  if( tmpdisp == NULL )
1464  {
1465  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_CUTOFFBOUND, DISP_DESC_CUTOFFBOUND, DISP_HEAD_CUTOFFBOUND,
1466  SCIP_DISPSTATUS_AUTO,
1467  dispCopyGcg,
1468  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputCutoffbound, NULL,
1470  }
1471  tmpdisp = SCIPfindDisp(scip, DISP_NAME_GAP);
1472  if( tmpdisp == NULL )
1473  {
1474  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_GAP, DISP_DESC_GAP, DISP_HEAD_GAP,
1475  SCIP_DISPSTATUS_AUTO,
1476  dispCopyGcg,
1477  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputGap, NULL,
1479  }
1480  tmpdisp = SCIPfindDisp(scip, DISP_NAME_PRIMALGAP);
1481  if( tmpdisp == NULL )
1482  {
1483  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_PRIMALGAP, DISP_DESC_PRIMALGAP, DISP_HEAD_PRIMALGAP,
1484  SCIP_DISPSTATUS_OFF,
1485  dispCopyGcg,
1486  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputPrimalgap, NULL,
1488  }
1489  tmpdisp = SCIPfindDisp(scip, DISP_NAME_NSOLS);
1490  if( tmpdisp == NULL )
1491  {
1492  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_NSOLS, DISP_DESC_NSOLS, DISP_HEAD_NSOLS,
1493  SCIP_DISPSTATUS_AUTO,
1494  dispCopyGcg,
1495  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNSols, NULL,
1497  }
1498  tmpdisp = SCIPfindDisp(scip, DISP_NAME_MLPITERATIONS);
1499  if( tmpdisp == NULL )
1500  {
1501  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_MLPITERATIONS, DISP_DESC_MLPITERATIONS, DISP_HEAD_MLPITERATIONS,
1502  SCIP_DISPSTATUS_AUTO, dispCopyGcg, NULL, NULL, NULL, NULL, NULL, SCIPdispOutputMlpiterations, NULL,
1504  }
1505  tmpdisp = SCIPfindDisp(scip, DISP_NAME_MVARS);
1506  if( tmpdisp == NULL )
1507  {
1508  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_MVARS, DISP_DESC_MVARS, DISP_HEAD_MVARS,
1509  SCIP_DISPSTATUS_AUTO, dispCopyGcg, NULL, NULL, NULL, NULL, NULL, SCIPdispOutputMvars, NULL,
1511  }
1512  tmpdisp = SCIPfindDisp(scip, DISP_NAME_MCONSS);
1513  if( tmpdisp == NULL )
1514  {
1515  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_MCONSS, DISP_DESC_MCONSS, DISP_HEAD_MCONSS,
1516  SCIP_DISPSTATUS_AUTO, dispCopyGcg, NULL, NULL, NULL, NULL, NULL, SCIPdispOutputMconss, NULL,
1518  }
1519  tmpdisp = SCIPfindDisp(scip, DISP_NAME_MCUTS);
1520  if( tmpdisp == NULL )
1521  {
1522  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_MCUTS, DISP_DESC_MCUTS, DISP_HEAD_MCUTS,
1523  SCIP_DISPSTATUS_AUTO, dispCopyGcg, NULL, NULL, NULL, NULL, NULL, SCIPdispOutputMcuts, NULL,
1525  }
1526  tmpdisp = SCIPfindDisp(scip, DISP_NAME_DEGENERACY);
1527  if( tmpdisp == NULL )
1528  {
1529  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_DEGENERACY, DISP_DESC_DEGENERACY, DISP_HEAD_DEGENERACY,
1530  SCIP_DISPSTATUS_AUTO, NULL, NULL, NULL, NULL, NULL, NULL, SCIPdispOutputDegeneracy, NULL,
1532  }
1533  tmpdisp = SCIPfindDisp(scip, DISP_NAME_SLPITERATIONS);
1534  if( tmpdisp == NULL )
1535  {
1536  SCIP_CALL( SCIPincludeDisp(scip, DISP_NAME_SLPITERATIONS, DISP_DESC_SLPITERATIONS, DISP_HEAD_SLPITERATIONS,
1537  SCIP_DISPSTATUS_AUTO, NULL, NULL, NULL, NULL, NULL, NULL, SCIPdispOutputSlpiterations, NULL,
1539  }
1540 
1541  return SCIP_OKAY;
1542 }
#define DISP_NAME_NEXTERNCANDS
Definition: disp_gcg.c:152
#define DISP_NAME_STRONGBRANCHS
Definition: disp_gcg.c:232
#define DISP_STRI_CONSS
Definition: disp_gcg.c:174
#define DISP_STRI_CURROWS
Definition: disp_gcg.c:198
#define DISP_DESC_CONSS
Definition: disp_gcg.c:169
#define DISP_PRIO_CURCOLS
Definition: disp_gcg.c:188
#define DISP_STRI_MLPITERATIONS
Definition: disp_gcg.c:342
#define DISP_POSI_CUTS
Definition: disp_gcg.c:205
#define DISP_PRIO_SEPAROUNDS
Definition: disp_gcg.c:212
#define DISP_DESC_MCONSS
Definition: disp_gcg.c:353
#define DISP_WIDT_LPOBJ
Definition: disp_gcg.c:251
#define DISP_DESC_NODESLEFT
Definition: disp_gcg.c:73
#define DISP_STRI_NEXTERNCANDS
Definition: disp_gcg.c:158
#define DISP_PRIO_MVARS
Definition: disp_gcg.c:348
#define DISP_NAME_PSEUDOOBJ
Definition: disp_gcg.c:240
#define DISP_POSI_LPCOND
Definition: disp_gcg.c:109
static SCIP_DECL_DISPCOPY(dispCopyGcg)
Definition: disp_gcg.c:374
#define DISP_DESC_PSEUDOOBJ
Definition: disp_gcg.c:241
#define DISP_STRI_MAXDEPTH
Definition: disp_gcg.c:134
#define DISP_DESC_MLPITERATIONS
Definition: disp_gcg.c:337
#define DISP_POSI_CURROWS
Definition: disp_gcg.c:197
#define DISP_PRIO_SOLFOUND
Definition: disp_gcg.c:52
GCG interface methods.
#define DISP_POSI_AVGDUALBOUND
Definition: disp_gcg.c:277
#define DISP_PRIO_PRIMALBOUND
Definition: disp_gcg.c:292
static SCIP_DECL_DISPINITSOL(SCIPdispInitsolSolFound)
Definition: disp_gcg.c:387
#define DISP_HEAD_CUTS
Definition: disp_gcg.c:202
#define DISP_NAME_GAP
Definition: disp_gcg.c:312
#define DISP_STRI_CURCONSS
Definition: disp_gcg.c:182
#define DISP_PRIO_CURCONSS
Definition: disp_gcg.c:180
#define DISP_PRIO_STRONGBRANCHS
Definition: disp_gcg.c:236
SCIP_Longint GCGmasterGetPricingSimplexIters(SCIP *scip)
#define DISP_PRIO_ESTIMATE
Definition: disp_gcg.c:268
#define DISP_POSI_LPITERATIONS
Definition: disp_gcg.c:85
#define DISP_PRIO_LPITERATIONS
Definition: disp_gcg.c:84
#define DISP_PRIO_PRIMALGAP
Definition: disp_gcg.c:324
#define DISP_POSI_CURDUALBOUND
Definition: disp_gcg.c:261
#define DISP_WIDT_POOLSIZE
Definition: disp_gcg.c:219
#define DISP_WIDT_NNODES
Definition: disp_gcg.c:67
#define DISP_NAME_ESTIMATE
Definition: disp_gcg.c:264
#define DISP_WIDT_CONFLICTS
Definition: disp_gcg.c:227
#define DISP_HEAD_AVGDUALBOUND
Definition: disp_gcg.c:274
#define DISP_STRI_TIME
Definition: disp_gcg.c:62
#define DISP_HEAD_CONSS
Definition: disp_gcg.c:170
GCG display columns.
#define DISP_WIDT_VARS
Definition: disp_gcg.c:163
#define DISP_POSI_MEMUSED
Definition: disp_gcg.c:117
#define DISP_DESC_NFRAC
Definition: disp_gcg.c:145
#define DISP_HEAD_NODESLEFT
Definition: disp_gcg.c:74
#define DISP_DESC_SOLFOUND
Definition: disp_gcg.c:49
#define DISP_POSI_NODESLEFT
Definition: disp_gcg.c:77
#define DISP_HEAD_MCONSS
Definition: disp_gcg.c:354
#define DISP_STRI_NFRAC
Definition: disp_gcg.c:150
#define DISP_POSI_DUALBOUND
Definition: disp_gcg.c:285
#define DISP_NAME_LPAVGITERS
Definition: disp_gcg.c:96
#define DISP_HEAD_CURROWS
Definition: disp_gcg.c:194
#define DISP_WIDT_GAP
Definition: disp_gcg.c:315
#define DISP_PRIO_GAP
Definition: disp_gcg.c:316
#define DISP_NAME_MEMUSED
Definition: disp_gcg.c:112
#define DISP_HEAD_LPAVGITERS
Definition: disp_gcg.c:98
#define DISP_POSI_NNODES
Definition: disp_gcg.c:69
#define DISP_WIDT_NODESLEFT
Definition: disp_gcg.c:75
#define DISP_POSI_PRIMALBOUND
Definition: disp_gcg.c:293
#define DISP_POSI_CURCOLS
Definition: disp_gcg.c:189
#define DISP_WIDT_LPCOND
Definition: disp_gcg.c:107
#define DISP_HEAD_MAXDEPTH
Definition: disp_gcg.c:130
#define DISP_NAME_SEPAROUNDS
Definition: disp_gcg.c:208
#define DISP_NAME_SOLFOUND
Definition: disp_gcg.c:48
#define DISP_PRIO_PLUNGEDEPTH
Definition: disp_gcg.c:140
#define DISP_PRIO_CONSS
Definition: disp_gcg.c:172
#define DISP_DESC_NEXTERNCANDS
Definition: disp_gcg.c:153
#define DISP_POSI_LPAVGITERS
Definition: disp_gcg.c:101
#define DISP_STRI_NSOLS
Definition: disp_gcg.c:334
#define DISP_NAME_CURDUALBOUND
Definition: disp_gcg.c:256
#define DISP_POSI_CONSS
Definition: disp_gcg.c:173
#define DISP_NAME_CURCOLS
Definition: disp_gcg.c:184
#define DISP_HEAD_STRONGBRANCHS
Definition: disp_gcg.c:234
#define DISP_POSI_VARS
Definition: disp_gcg.c:165
#define DISP_DESC_CURCOLS
Definition: disp_gcg.c:185
#define DISP_WIDT_DEGENERACY
Definition: disp_gcg.c:307
#define DISP_WIDT_LPAVGITERS
Definition: disp_gcg.c:99
#define DISP_HEAD_SLPITERATIONS
Definition: disp_gcg.c:90
#define DISP_STRI_NNODES
Definition: disp_gcg.c:70
#define DISP_POSI_DEPTH
Definition: disp_gcg.c:125
#define DISP_DESC_CUTOFFBOUND
Definition: disp_gcg.c:297
SCIP * GCGgetPricingprob(SCIP *scip, int pricingprobnr)
Definition: relax_gcg.c:3939
SCIP_Real GCGgetGap(SCIP *scip)
Definition: relax_gcg.c:5501
#define DISP_NAME_VARS
Definition: disp_gcg.c:160
#define DISP_PRIO_CUTS
Definition: disp_gcg.c:204
#define DISP_STRI_LPAVGITERS
Definition: disp_gcg.c:102
#define DISP_STRI_MEMUSED
Definition: disp_gcg.c:118
#define DISP_WIDT_AVGDUALBOUND
Definition: disp_gcg.c:275
#define DISP_NAME_CURCONSS
Definition: disp_gcg.c:176
#define DISP_NAME_MCUTS
Definition: disp_gcg.c:360
#define DISP_DESC_ESTIMATE
Definition: disp_gcg.c:265
#define DISP_WIDT_NEXTERNCANDS
Definition: disp_gcg.c:155
#define DISP_DESC_MVARS
Definition: disp_gcg.c:345
#define DISP_DESC_TIME
Definition: disp_gcg.c:57
SCIP_RETCODE SCIPincludeDispGcg(SCIP *scip)
Definition: disp_gcg.c:1186
#define DISP_WIDT_MEMUSED
Definition: disp_gcg.c:115
#define DISP_STRI_DUALBOUND
Definition: disp_gcg.c:286
#define DISP_POSI_DEGENERACY
Definition: disp_gcg.c:309
#define DISP_WIDT_PRIMALBOUND
Definition: disp_gcg.c:291
#define DISP_STRI_SOLFOUND
Definition: disp_gcg.c:54
#define DISP_STRI_MCUTS
Definition: disp_gcg.c:366
#define DISP_HEAD_CUTOFFBOUND
Definition: disp_gcg.c:298
int GCGgetNPricingprobs(SCIP *scip)
Definition: relax_gcg.c:3979
#define DISP_POSI_NFRAC
Definition: disp_gcg.c:149
#define DISP_WIDT_DUALBOUND
Definition: disp_gcg.c:283
#define DISP_PRIO_PSEUDOOBJ
Definition: disp_gcg.c:244
GCG variable pricer.
#define DISP_WIDT_LPITERATIONS
Definition: disp_gcg.c:83
#define DISP_DESC_SLPITERATIONS
Definition: disp_gcg.c:89
#define DISP_NAME_DUALBOUND
Definition: disp_gcg.c:280
#define DISP_HEAD_NNODES
Definition: disp_gcg.c:66
#define DISP_HEAD_TIME
Definition: disp_gcg.c:58
#define DISP_PRIO_MAXDEPTH
Definition: disp_gcg.c:132
#define DISP_NAME_CUTS
Definition: disp_gcg.c:200
#define DISP_STRI_SLPITERATIONS
Definition: disp_gcg.c:94
#define DISP_WIDT_CURROWS
Definition: disp_gcg.c:195
#define DISP_HEAD_MLPITERATIONS
Definition: disp_gcg.c:338
#define DISP_HEAD_DEPTH
Definition: disp_gcg.c:122
#define DISP_STRI_DEPTH
Definition: disp_gcg.c:126
#define DISP_STRI_CURCOLS
Definition: disp_gcg.c:190
#define DISP_POSI_STRONGBRANCHS
Definition: disp_gcg.c:237
#define DISP_PRIO_DUALBOUND
Definition: disp_gcg.c:284
#define DISP_DESC_CURROWS
Definition: disp_gcg.c:193
#define DISP_DESC_SEPAROUNDS
Definition: disp_gcg.c:209
#define DISP_DESC_PRIMALBOUND
Definition: disp_gcg.c:289
#define DISP_WIDT_NSOLS
Definition: disp_gcg.c:331
SCIP * GCGgetMasterprob(SCIP *scip)
Definition: relax_gcg.c:3920
#define DISP_PRIO_CURDUALBOUND
Definition: disp_gcg.c:260
#define DISP_WIDT_TIME
Definition: disp_gcg.c:59
#define DISP_STRI_VARS
Definition: disp_gcg.c:166
#define DISP_DESC_LPCOND
Definition: disp_gcg.c:105
#define DISP_NAME_NNODES
Definition: disp_gcg.c:64
#define DISP_POSI_TIME
Definition: disp_gcg.c:61
#define DISP_POSI_LPOBJ
Definition: disp_gcg.c:253
#define DISP_STRI_MVARS
Definition: disp_gcg.c:350
#define DISP_WIDT_CUTS
Definition: disp_gcg.c:203
#define DISP_PRIO_MEMUSED
Definition: disp_gcg.c:116
#define DISP_STRI_LPITERATIONS
Definition: disp_gcg.c:86
#define DISP_NAME_LPOBJ
Definition: disp_gcg.c:248
#define DISP_STRI_DEGENERACY
Definition: disp_gcg.c:310
#define DISP_WIDT_ESTIMATE
Definition: disp_gcg.c:267
#define DISP_POSI_NEXTERNCANDS
Definition: disp_gcg.c:157
#define DISP_HEAD_CURDUALBOUND
Definition: disp_gcg.c:258
#define DISP_DESC_GAP
Definition: disp_gcg.c:313
#define DISP_WIDT_CURCOLS
Definition: disp_gcg.c:187
#define DISP_NAME_TIME
Definition: disp_gcg.c:56
#define DISP_HEAD_LPITERATIONS
Definition: disp_gcg.c:82
#define DISP_POSI_MCUTS
Definition: disp_gcg.c:365
#define DISP_NAME_DEPTH
Definition: disp_gcg.c:120
#define DISP_WIDT_SLPITERATIONS
Definition: disp_gcg.c:91
#define DISP_PRIO_POOLSIZE
Definition: disp_gcg.c:220
#define DISP_STRI_MCONSS
Definition: disp_gcg.c:358
SCIP_Real GCGgetDualbound(SCIP *scip)
Definition: relax_gcg.c:5445
#define DISP_STRI_CURDUALBOUND
Definition: disp_gcg.c:262
#define DISP_WIDT_CUTOFFBOUND
Definition: disp_gcg.c:299
static SCIP_DECL_DISPOUTPUT(SCIPdispOutputSolFound)
Definition: disp_gcg.c:401
#define DISP_WIDT_CONSS
Definition: disp_gcg.c:171
#define DISP_DESC_NSOLS
Definition: disp_gcg.c:329
#define DISP_STRI_AVGDUALBOUND
Definition: disp_gcg.c:278
#define DISP_DESC_PRIMALGAP
Definition: disp_gcg.c:321
#define DISP_DESC_LPOBJ
Definition: disp_gcg.c:249
#define DISP_PRIO_SLPITERATIONS
Definition: disp_gcg.c:92
SCIP_Real GCGgetPrimalbound(SCIP *scip)
Definition: relax_gcg.c:5473
DEC_DECMODE GCGgetDecompositionMode(SCIP *scip)
Definition: relax_gcg.c:5123
#define DISP_POSI_ESTIMATE
Definition: disp_gcg.c:269
#define DISP_DESC_POOLSIZE
Definition: disp_gcg.c:217
#define DISP_NAME_PLUNGEDEPTH
Definition: disp_gcg.c:136
#define DISP_POSI_CONFLICTS
Definition: disp_gcg.c:229
#define DISP_POSI_POOLSIZE
Definition: disp_gcg.c:221
#define DISP_DESC_AVGDUALBOUND
Definition: disp_gcg.c:273
#define DISP_HEAD_POOLSIZE
Definition: disp_gcg.c:218
@ DEC_DECMODE_DANTZIGWOLFE
Definition: type_decomp.h:61
#define DISP_NAME_NSOLS
Definition: disp_gcg.c:328
#define DISP_STRI_SEPAROUNDS
Definition: disp_gcg.c:214
#define DISP_HEAD_PSEUDOOBJ
Definition: disp_gcg.c:242
#define DISP_DESC_CURDUALBOUND
Definition: disp_gcg.c:257
#define DISP_PRIO_AVGDUALBOUND
Definition: disp_gcg.c:276
#define DISP_PRIO_NSOLS
Definition: disp_gcg.c:332
#define DISP_HEAD_SEPAROUNDS
Definition: disp_gcg.c:210
#define DISP_PRIO_LPOBJ
Definition: disp_gcg.c:252
#define DISP_DESC_CUTS
Definition: disp_gcg.c:201
#define DISP_POSI_MCONSS
Definition: disp_gcg.c:357
#define DISP_STRI_CUTOFFBOUND
Definition: disp_gcg.c:302
#define DISP_WIDT_CURCONSS
Definition: disp_gcg.c:179
#define DISP_NAME_SLPITERATIONS
Definition: disp_gcg.c:88
#define DISP_HEAD_NFRAC
Definition: disp_gcg.c:146
#define DISP_PRIO_TIME
Definition: disp_gcg.c:60
#define DISP_HEAD_MVARS
Definition: disp_gcg.c:346
#define DISP_POSI_PRIMALGAP
Definition: disp_gcg.c:325
#define DISP_DESC_LPAVGITERS
Definition: disp_gcg.c:97
#define DISP_HEAD_CONFLICTS
Definition: disp_gcg.c:226
#define DISP_STRI_ESTIMATE
Definition: disp_gcg.c:270
#define DISP_POSI_SEPAROUNDS
Definition: disp_gcg.c:213
#define DISP_POSI_PSEUDOOBJ
Definition: disp_gcg.c:245
#define DISP_STRI_POOLSIZE
Definition: disp_gcg.c:222
#define DISP_STRI_NODESLEFT
Definition: disp_gcg.c:78
#define DISP_HEAD_CURCONSS
Definition: disp_gcg.c:178
#define DISP_POSI_CURCONSS
Definition: disp_gcg.c:181
#define DISP_DESC_DUALBOUND
Definition: disp_gcg.c:281
#define DISP_PRIO_DEPTH
Definition: disp_gcg.c:124
#define DISP_WIDT_STRONGBRANCHS
Definition: disp_gcg.c:235
#define DISP_NAME_CONFLICTS
Definition: disp_gcg.c:224
#define DISP_WIDT_MCONSS
Definition: disp_gcg.c:355
#define DISP_HEAD_CURCOLS
Definition: disp_gcg.c:186
#define DISP_PRIO_LPCOND
Definition: disp_gcg.c:108
#define DISP_DESC_MEMUSED
Definition: disp_gcg.c:113
GCG relaxator.
#define DISP_WIDT_DEPTH
Definition: disp_gcg.c:123
#define DISP_STRI_PRIMALGAP
Definition: disp_gcg.c:326
SCIP_Real GCGgetDegeneracy(SCIP *scip)
Definition: relax_gcg.c:4978
#define DISP_STRI_LPCOND
Definition: disp_gcg.c:110
#define DISP_NAME_CURROWS
Definition: disp_gcg.c:192
#define DISP_POSI_MVARS
Definition: disp_gcg.c:349
#define DISP_WIDT_PLUNGEDEPTH
Definition: disp_gcg.c:139
#define DISP_STRI_CUTS
Definition: disp_gcg.c:206
#define DISP_NAME_NFRAC
Definition: disp_gcg.c:144
#define DISP_HEAD_MEMUSED
Definition: disp_gcg.c:114
#define DISP_NAME_PRIMALBOUND
Definition: disp_gcg.c:288
#define DISP_NAME_PRIMALGAP
Definition: disp_gcg.c:320
#define DISP_DESC_PLUNGEDEPTH
Definition: disp_gcg.c:137
#define DISP_PRIO_NFRAC
Definition: disp_gcg.c:148
#define DISP_STRI_PLUNGEDEPTH
Definition: disp_gcg.c:142
#define DISP_WIDT_MCUTS
Definition: disp_gcg.c:363
#define DISP_NAME_MCONSS
Definition: disp_gcg.c:352
#define DISP_DESC_CONFLICTS
Definition: disp_gcg.c:225
#define DISP_HEAD_LPCOND
Definition: disp_gcg.c:106
#define DISP_HEAD_PLUNGEDEPTH
Definition: disp_gcg.c:138
#define DISP_POSI_GAP
Definition: disp_gcg.c:317
#define DISP_STRI_STRONGBRANCHS
Definition: disp_gcg.c:238
#define DISP_POSI_SOLFOUND
Definition: disp_gcg.c:53
#define DISP_POSI_MAXDEPTH
Definition: disp_gcg.c:133
#define DISP_DESC_STRONGBRANCHS
Definition: disp_gcg.c:233
#define DISP_PRIO_MCUTS
Definition: disp_gcg.c:364
#define DISP_PRIO_CUTOFFBOUND
Definition: disp_gcg.c:300
#define DISP_POSI_CUTOFFBOUND
Definition: disp_gcg.c:301
#define DISP_WIDT_PSEUDOOBJ
Definition: disp_gcg.c:243
#define DISP_PRIO_NEXTERNCANDS
Definition: disp_gcg.c:156
#define DISP_HEAD_NEXTERNCANDS
Definition: disp_gcg.c:154
#define DISP_NAME_MLPITERATIONS
Definition: disp_gcg.c:336
#define DISP_NAME_LPCOND
Definition: disp_gcg.c:104
#define DISP_NAME_LPITERATIONS
Definition: disp_gcg.c:80
#define DISP_DESC_MCUTS
Definition: disp_gcg.c:361
#define DISP_PRIO_NNODES
Definition: disp_gcg.c:68
#define DISP_POSI_SLPITERATIONS
Definition: disp_gcg.c:93
#define DISP_NAME_CONSS
Definition: disp_gcg.c:168
#define DISP_WIDT_CURDUALBOUND
Definition: disp_gcg.c:259
#define DISP_STRI_CONFLICTS
Definition: disp_gcg.c:230
#define DISP_PRIO_CONFLICTS
Definition: disp_gcg.c:228
#define DISP_DESC_DEGENERACY
Definition: disp_gcg.c:305
#define DISP_PRIO_CURROWS
Definition: disp_gcg.c:196
#define DISP_POSI_NSOLS
Definition: disp_gcg.c:333
#define DISP_WIDT_PRIMALGAP
Definition: disp_gcg.c:323
#define DISP_PRIO_VARS
Definition: disp_gcg.c:164
#define DISP_NAME_AVGDUALBOUND
Definition: disp_gcg.c:272
#define DISP_HEAD_SOLFOUND
Definition: disp_gcg.c:50
#define DISP_HEAD_GAP
Definition: disp_gcg.c:314
#define DISP_HEAD_VARS
Definition: disp_gcg.c:162
#define DISP_DESC_CURCONSS
Definition: disp_gcg.c:177
#define DISP_STRI_PSEUDOOBJ
Definition: disp_gcg.c:246
#define DISP_PRIO_DEGENERACY
Definition: disp_gcg.c:308
#define DISP_PRIO_MCONSS
Definition: disp_gcg.c:356
#define DISP_WIDT_MVARS
Definition: disp_gcg.c:347
#define DISP_HEAD_PRIMALBOUND
Definition: disp_gcg.c:290
#define DISP_HEAD_ESTIMATE
Definition: disp_gcg.c:266
#define DISP_WIDT_NFRAC
Definition: disp_gcg.c:147
#define DISP_DESC_NNODES
Definition: disp_gcg.c:65
#define DISP_STRI_GAP
Definition: disp_gcg.c:318
#define DISP_POSI_MLPITERATIONS
Definition: disp_gcg.c:341
#define DISP_STRI_LPOBJ
Definition: disp_gcg.c:254
#define DISP_POSI_PLUNGEDEPTH
Definition: disp_gcg.c:141
#define DISP_PRIO_MLPITERATIONS
Definition: disp_gcg.c:340
#define DISP_HEAD_NSOLS
Definition: disp_gcg.c:330
#define DISP_HEAD_MCUTS
Definition: disp_gcg.c:362
#define DISP_HEAD_DEGENERACY
Definition: disp_gcg.c:306
#define DISP_NAME_POOLSIZE
Definition: disp_gcg.c:216
#define DISP_NAME_DEGENERACY
Definition: disp_gcg.c:304
#define DISP_HEAD_DUALBOUND
Definition: disp_gcg.c:282
#define DISP_WIDT_MLPITERATIONS
Definition: disp_gcg.c:339
#define DISP_WIDT_SOLFOUND
Definition: disp_gcg.c:51
#define DISP_STRI_PRIMALBOUND
Definition: disp_gcg.c:294
#define DISP_DESC_DEPTH
Definition: disp_gcg.c:121
#define DISP_NAME_NODESLEFT
Definition: disp_gcg.c:72
#define DISP_WIDT_MAXDEPTH
Definition: disp_gcg.c:131
#define DISP_NAME_MVARS
Definition: disp_gcg.c:344
#define DISP_HEAD_PRIMALGAP
Definition: disp_gcg.c:322
#define DISP_PRIO_LPAVGITERS
Definition: disp_gcg.c:100
#define DISP_PRIO_NODESLEFT
Definition: disp_gcg.c:76
#define DISP_DESC_LPITERATIONS
Definition: disp_gcg.c:81
#define DISP_NAME_CUTOFFBOUND
Definition: disp_gcg.c:296
#define DISP_WIDT_SEPAROUNDS
Definition: disp_gcg.c:211
#define DISP_HEAD_LPOBJ
Definition: disp_gcg.c:250
#define DISP_DESC_VARS
Definition: disp_gcg.c:161
#define DISP_DESC_MAXDEPTH
Definition: disp_gcg.c:129
#define DISP_NAME_MAXDEPTH
Definition: disp_gcg.c:128