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