Scippy

SCIP

Solving Constraint Integer Programs

disp_default.c
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the program and library */
4 /* SCIP --- Solving Constraint Integer Programs */
5 /* */
6 /* Copyright 2002-2022 Zuse Institute Berlin */
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  {
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 
430 
431  return SCIP_OKAY;
432 }
433 
434 /** returns TRUE if this solution should be displayed in the output */
435 static
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 
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 
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 
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 */
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 */
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 
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 ",
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 
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 
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 
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 
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  {
760  infostr = "LP ";
761  break;
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;
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*/
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
1253  {
1254  /* in case we could not prove whether the problem is unbounded or infeasible, we want to terminate with
1255  * gap = +inf instead of gap = 0
1256  */
1258  gap = SCIPinfinity(scip);
1259  else
1260  gap = 0.0;
1261  }
1262  else
1263  {
1264  primalbound = SCIPgetPrimalbound(scip);
1265  dualbound = SCIPgetDualbound(scip);
1266 
1267  if( SCIPisEQ(scip, primalbound, dualbound) )
1268  gap = 0.0;
1269  else if( SCIPisZero(scip, primalbound)
1270  || SCIPisInfinity(scip, REALABS(primalbound))
1271  || primalbound * dualbound < 0.0 )
1272  gap = SCIPinfinity(scip);
1273  else
1274  gap = REALABS((primalbound - dualbound))/REALABS(primalbound + SCIPepsilon(scip));
1275  }
1276 
1277  if( SCIPisInfinity(scip, gap) )
1278  SCIPinfoMessage(scip, file, " Inf ");
1279  else if( gap >= 100.00 )
1280  SCIPinfoMessage(scip, file, " Large ");
1281  else
1282  SCIPinfoMessage(scip, file, "%7.2f%%", 100.0*gap);
1283 
1284  return SCIP_OKAY;
1285 }
1286 
1287 /** output method of display column to output file stream 'file' for number of found solutions */
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 */
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 
1360  dispCopyDefault,
1361  NULL, NULL, NULL, SCIPdispInitsolSolFound, NULL, SCIPdispOutputSolFound, NULL,
1363 
1364  assert(SCIPfindDisp(scip, DISP_NAME_CONCSOLFOUND) == NULL);
1367  dispCopyDefault,
1368  NULL, NULL, NULL, SCIPdispInitsolConcSolFound, SCIPdispExitsolConcSolFound, SCIPdispOutputConcSolFound, NULL,
1370  tmpdisp = SCIPfindDisp(scip, DISP_NAME_CONCSOLFOUND);
1372 
1373  assert(SCIPfindDisp(scip, DISP_NAME_TIME) == NULL);
1376  dispCopyDefault,
1377  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputSolvingTime, NULL,
1379  tmpdisp = SCIPfindDisp(scip, DISP_NAME_TIME);
1381 
1382  assert(SCIPfindDisp(scip, DISP_NAME_NNODES) == NULL);
1385  dispCopyDefault,
1386  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNNodes, NULL,
1388 
1389  assert(SCIPfindDisp(scip, DISP_NAME_NODESLEFT) == NULL);
1392  dispCopyDefault,
1393  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNNodesLeft, NULL,
1395 
1396  /* add objective leaves display */
1397  assert(SCIPfindDisp(scip, DISP_NAME_NOBJLEAVES) == NULL);
1401 
1402  /* add infeasible leaves display */
1403  assert(SCIPfindDisp(scip, DISP_NAME_NINFEASLEAVES) == NULL);
1407 
1408  assert(SCIPfindDisp(scip, DISP_NAME_LPITERATIONS) == NULL);
1411  dispCopyDefault,
1412  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNLPIterations, NULL,
1414 
1415  assert(SCIPfindDisp(scip, DISP_NAME_LPAVGITERS) == NULL);
1418  dispCopyDefault,
1419  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNLPAvgIters, NULL,
1421 
1422  assert(SCIPfindDisp(scip, DISP_NAME_LPCOND) == NULL);
1425  dispCopyDefault,
1426  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputLPCondition, NULL,
1428 
1429  assert(SCIPfindDisp(scip, DISP_NAME_MEMUSED) == NULL);
1432  dispCopyDefault,
1433  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputMemUsed, NULL,
1435 
1436  assert(SCIPfindDisp(scip, DISP_NAME_CONCMEMUSED) == NULL);
1439  dispCopyDefault,
1440  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputConcMemUsed, NULL,
1442  tmpdisp = SCIPfindDisp(scip, DISP_NAME_CONCMEMUSED);
1444 
1445  assert(SCIPfindDisp(scip, DISP_NAME_MEMTOTAL) == NULL);
1448  dispCopyDefault,
1449  NULL, NULL, NULL, SCIPdispInitsolSolFound, NULL, SCIPdispOutputMemUsedTotal, NULL,
1451 
1452  assert(SCIPfindDisp(scip, DISP_NAME_DEPTH) == NULL);
1455  dispCopyDefault,
1456  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputDepth, NULL,
1458 
1459  assert(SCIPfindDisp(scip, DISP_NAME_MAXDEPTH) == NULL);
1462  dispCopyDefault,
1463  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputMaxDepth, NULL,
1465 
1466  assert(SCIPfindDisp(scip, DISP_NAME_PLUNGEDEPTH) == NULL);
1469  dispCopyDefault,
1470  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputPlungeDepth, NULL,
1472 
1473  assert(SCIPfindDisp(scip, DISP_NAME_NFRAC) == NULL);
1476  dispCopyDefault,
1477  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNFrac, NULL,
1479 
1480  assert(SCIPfindDisp(scip, DISP_NAME_NEXTERNCANDS) == NULL);
1483  dispCopyDefault,
1484  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNExternCands, NULL,
1486 
1487  assert(SCIPfindDisp(scip, DISP_NAME_VARS) == NULL);
1490  dispCopyDefault,
1491  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNVars, NULL,
1493 
1494  assert(SCIPfindDisp(scip, DISP_NAME_CONSS) == NULL);
1497  dispCopyDefault,
1498  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNConss, NULL,
1500 
1501  assert(SCIPfindDisp(scip, DISP_NAME_CURCONSS) == NULL);
1504  dispCopyDefault,
1505  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNCurConss, NULL,
1507 
1508  assert(SCIPfindDisp(scip, DISP_NAME_CURCOLS) == NULL);
1511  dispCopyDefault,
1512  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNCurCols, NULL,
1514 
1515  assert(SCIPfindDisp(scip, DISP_NAME_CURROWS) == NULL);
1518  dispCopyDefault,
1519  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNCurRows, NULL,
1521 
1522  assert(SCIPfindDisp(scip, DISP_NAME_CUTS) == NULL);
1525  dispCopyDefault,
1526  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNAppliedCuts, NULL,
1528 
1529  assert(SCIPfindDisp(scip, DISP_NAME_SEPAROUNDS) == NULL);
1532  dispCopyDefault,
1533  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNSepaRounds, NULL,
1535 
1536  assert(SCIPfindDisp(scip, DISP_NAME_POOLSIZE) == NULL);
1539  dispCopyDefault,
1540  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputCutPoolSize, NULL,
1542 
1543  assert(SCIPfindDisp(scip,DISP_NAME_CONFLICTS) == NULL);
1546  dispCopyDefault,
1547  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNConflicts, NULL,
1549 
1550  assert(SCIPfindDisp(scip, DISP_NAME_STRONGBRANCHS) == NULL);
1553  dispCopyDefault,
1554  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNStrongbranchs, NULL,
1556 
1557  assert(SCIPfindDisp(scip, DISP_NAME_PSEUDOOBJ) == NULL);
1560  dispCopyDefault,
1561  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputPseudoObjval, NULL,
1563 
1564  assert(SCIPfindDisp(scip, DISP_NAME_LPOBJ) == NULL);
1567  dispCopyDefault,
1568  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputLPObjval, NULL,
1570 
1571  assert(SCIPfindDisp(scip, DISP_NAME_CURDUALBOUND) == NULL);
1574  dispCopyDefault,
1575  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputCurDualbound, NULL,
1577 
1578  assert(SCIPfindDisp(scip, DISP_NAME_ESTIMATE) == NULL);
1581  dispCopyDefault,
1582  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputLocalOrigEstimate, NULL,
1584 
1585  assert(SCIPfindDisp(scip, DISP_NAME_AVGDUALBOUND) == NULL);
1588  dispCopyDefault,
1589  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputAvgDualbound, NULL,
1591 
1592  assert(SCIPfindDisp(scip, DISP_NAME_DUALBOUND) == NULL);
1595  dispCopyDefault,
1596  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputDualbound, NULL,
1598 
1599  assert(SCIPfindDisp(scip, DISP_NAME_PRIMALBOUND) == NULL);
1602  dispCopyDefault,
1603  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputPrimalbound, NULL,
1605 
1606  assert(SCIPfindDisp(scip, DISP_NAME_CONCDUALBOUND) == NULL);
1609  dispCopyDefault,
1610  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputConcDualbound, NULL,
1612  tmpdisp = SCIPfindDisp(scip, DISP_NAME_CONCDUALBOUND);
1614 
1615  assert(SCIPfindDisp(scip, DISP_NAME_CONCPRIMALBOUND) == NULL);
1618  dispCopyDefault,
1619  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputConcPrimalbound, NULL,
1621  tmpdisp = SCIPfindDisp(scip, DISP_NAME_CONCPRIMALBOUND);
1623 
1624  assert(SCIPfindDisp(scip, DISP_NAME_CUTOFFBOUND) == NULL);
1627  dispCopyDefault,
1628  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputCutoffbound, NULL,
1630 
1631  assert(SCIPfindDisp(scip, DISP_NAME_GAP) == NULL);
1634  dispCopyDefault,
1635  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputGap, NULL,
1637 
1638  assert(SCIPfindDisp(scip, DISP_NAME_CONCGAP) == NULL);
1641  dispCopyDefault,
1642  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputConcGap, NULL,
1644  tmpdisp = SCIPfindDisp(scip, DISP_NAME_CONCGAP);
1646 
1647  assert(SCIPfindDisp(scip, DISP_NAME_PRIMALGAP) == NULL);
1650  dispCopyDefault,
1651  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputPrimalgap, NULL,
1653 
1654  assert(SCIPfindDisp(scip, DISP_NAME_NSOLS) == NULL);
1657  dispCopyDefault,
1658  NULL, NULL, NULL, NULL, NULL, SCIPdispOutputNSols, NULL,
1660 
1661  return SCIP_OKAY;
1662 }
1663 
#define DISP_WIDT_LPAVGITERS
Definition: disp_default.c:111
SCIP_Bool SCIPsolIsOriginal(SCIP_SOL *sol)
Definition: sol.c:2530
#define DISP_NAME_PLUNGEDEPTH
Definition: disp_default.c:165
#define DISP_WIDT_CURDUALBOUND
Definition: disp_default.c:288
#define DISP_NAME_CONCPRIMALBOUND
Definition: disp_default.c:333
#define DISP_DESC_DEPTH
Definition: disp_default.c:150
#define DISP_WIDT_CONCMEMUSED
Definition: disp_default.c:135
#define DISP_POSI_NFRAC
Definition: disp_default.c:178
#define DISP_PRIO_CONCSOLFOUND
Definition: disp_default.c:71
#define DISP_PRIO_MEMTOTAL
Definition: disp_default.c:145
SCIP_Real SCIPgetSolvingTime(SCIP *scip)
Definition: scip_timing.c:378
SCIP_Longint SCIPgetNRootLPIterations(SCIP *scip)
#define DISP_DESC_MEMTOTAL
Definition: disp_default.c:141
#define DISP_NAME_CUTS
Definition: disp_default.c:229
#define DISP_NAME_DUALBOUND
Definition: disp_default.c:309
#define DISP_NAME_GAP
Definition: disp_default.c:349
int SCIPgetPlungeDepth(SCIP *scip)
Definition: scip_tree.c:713
#define DISP_HEAD_NOBJLEAVES
Definition: disp_default.c:384
#define DISP_POSI_LPAVGITERS
Definition: disp_default.c:113
#define DISP_PRIO_NODESLEFT
Definition: disp_default.c:95
#define DISP_NAME_CONCDUALBOUND
Definition: disp_default.c:317
struct SCIP_DispData SCIP_DISPDATA
Definition: type_disp.h:76
#define DISP_WIDT_NSOLS
Definition: disp_default.c:376
#define DISP_HEAD_CURCONSS
Definition: disp_default.c:207
#define DISP_DESC_SEPAROUNDS
Definition: disp_default.c:238
SCIP_Longint SCIPgetNLPIterations(SCIP *scip)
#define DISP_POSI_NSOLS
Definition: disp_default.c:378
SCIP_Bool SCIPisFeasLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
#define DISP_STRI_NSOLS
Definition: disp_default.c:379
#define DISP_NAME_POOLSIZE
Definition: disp_default.c:245
#define DISP_PRIO_CURCONSS
Definition: disp_default.c:209
#define DISP_POSI_STRONGBRANCHS
Definition: disp_default.c:266
public methods for memory management
#define DISP_HEAD_VARS
Definition: disp_default.c:191
SCIP_Real SCIPgetCutoffbound(SCIP *scip)
SCIP_Real SCIPgetPrimalbound(SCIP *scip)
#define DISP_NAME_CONFLICTS
Definition: disp_default.c:253
#define DISP_POSI_TIME
Definition: disp_default.c:80
#define DISP_STRI_CONSS
Definition: disp_default.c:203
#define DISP_POSI_CUTS
Definition: disp_default.c:234
#define DISP_DESC_LPOBJ
Definition: disp_default.c:278
SCIP_Real SCIPgetConcurrentPrimalbound(SCIP *scip)
Definition: concurrent.c:320
SCIP_Longint SCIPgetNSolsFound(SCIP *scip)
#define DISP_STRI_MEMUSED
Definition: disp_default.c:130
#define DISP_HEAD_STRONGBRANCHS
Definition: disp_default.c:263
#define DISP_HEAD_CONCSOLFOUND
Definition: disp_default.c:69
#define DISP_WIDT_VARS
Definition: disp_default.c:192
#define DISP_POSI_SEPAROUNDS
Definition: disp_default.c:242
#define DISP_STRI_NOBJLEAVES
Definition: disp_default.c:388
#define DISP_PRIO_NSOLS
Definition: disp_default.c:377
#define DISP_HEAD_CUTOFFBOUND
Definition: disp_default.c:343
#define DISP_WIDT_AVGDUALBOUND
Definition: disp_default.c:304
#define DISP_PRIO_CONCPRIMALBOUND
Definition: disp_default.c:337
void SCIPdispLongint(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, SCIP_Longint val, int width)
Definition: disp.c:581
#define DISP_DESC_CONCDUALBOUND
Definition: disp_default.c:318
#define DISP_HEAD_CONCDUALBOUND
Definition: disp_default.c:319
static SCIP_DECL_DISPINITSOL(SCIPdispInitsolSolFound)
Definition: disp_default.c:422
public methods for timing
#define DISP_PRIO_DEPTH
Definition: disp_default.c:153
SCIP_Longint SCIPgetNConflictDualproofsApplied(SCIP *scip)
#define DISP_PRIO_NOBJLEAVES
Definition: disp_default.c:386
#define DISP_STRI_PSEUDOOBJ
Definition: disp_default.c:275
#define DISP_NAME_NOBJLEAVES
Definition: disp_default.c:382
interface methods for specific LP solvers
#define DISP_PRIO_CONCGAP
Definition: disp_default.c:361
#define DISP_WIDT_DEPTH
Definition: disp_default.c:152
SCIP_RETCODE SCIPgetLPI(SCIP *scip, SCIP_LPI **lpi)
Definition: scip_lp.c:985
#define DISP_DESC_ESTIMATE
Definition: disp_default.c:294
#define DISP_DESC_CONCMEMUSED
Definition: disp_default.c:133
#define DISP_DESC_DUALBOUND
Definition: disp_default.c:310
#define DISP_POSI_PRIMALGAP
Definition: disp_default.c:370
int SCIPgetMaxDepth(SCIP *scip)
#define DISP_WIDT_SEPAROUNDS
Definition: disp_default.c:240
#define DISP_POSI_PSEUDOOBJ
Definition: disp_default.c:274
#define DISP_NAME_NFRAC
Definition: disp_default.c:173
#define DISP_PRIO_CONCMEMUSED
Definition: disp_default.c:136
#define DISP_HEAD_CURDUALBOUND
Definition: disp_default.c:287
#define DISP_STRI_CURCONSS
Definition: disp_default.c:211
#define DISP_DESC_PLUNGEDEPTH
Definition: disp_default.c:166
SCIP_Longint SCIPgetNStrongbranchs(SCIP *scip)
#define DISP_HEAD_NEXTERNCANDS
Definition: disp_default.c:183
#define DISP_STRI_SOLFOUND
Definition: disp_default.c:65
SCIP_Real SCIPinfinity(SCIP *scip)
#define DISP_PRIO_CUTOFFBOUND
Definition: disp_default.c:345
static SCIP_DECL_DISPCOPY(dispCopyDefault)
Definition: disp_default.c:406
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
#define DISP_STRI_MEMTOTAL
Definition: disp_default.c:147
#define DISP_WIDT_MEMTOTAL
Definition: disp_default.c:143
#define DISP_HEAD_LPOBJ
Definition: disp_default.c:279
#define DISP_NAME_TIME
Definition: disp_default.c:75
#define DISP_WIDT_CUTS
Definition: disp_default.c:232
#define DISP_DESC_NNODES
Definition: disp_default.c:84
#define DISP_NAME_NODESLEFT
Definition: disp_default.c:91
#define DISP_HEAD_LPAVGITERS
Definition: disp_default.c:110
public methods for displaying runtime statistics
int SCIPgetNNodesLeft(SCIP *scip)
Definition: scip_tree.c:644
default display columns
#define DISP_STRI_PRIMALGAP
Definition: disp_default.c:371
#define DISP_POSI_CONCSOLFOUND
Definition: disp_default.c:72
#define DISP_NAME_STRONGBRANCHS
Definition: disp_default.c:261
#define DISP_NAME_SEPAROUNDS
Definition: disp_default.c:237
#define SCIPfreeBlockMemory(scip, ptr)
Definition: scip_mem.h:108
#define DISP_WIDT_CONFLICTS
Definition: disp_default.c:256
#define DISP_POSI_AVGDUALBOUND
Definition: disp_default.c:306
#define DISP_DESC_STRONGBRANCHS
Definition: disp_default.c:262
#define DISP_WIDT_MAXDEPTH
Definition: disp_default.c:160
#define DISP_POSI_CONCMEMUSED
Definition: disp_default.c:137
#define DISP_DESC_LPCOND
Definition: disp_default.c:117
SCIP_MESSAGEHDLR * SCIPgetMessagehdlr(SCIP *scip)
Definition: scip_message.c:88
SCIP_RETCODE SCIPlpiGetRealSolQuality(SCIP_LPI *lpi, SCIP_LPSOLQUALITY qualityindicator, SCIP_Real *quality)
Definition: lpi_clp.cpp:2940
#define DISP_STRI_CONCGAP
Definition: disp_default.c:363
#define DISP_WIDT_LPITERATIONS
Definition: disp_default.c:103
#define DISP_STRI_DEPTH
Definition: disp_default.c:155
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
#define DISP_WIDT_MEMONLY
Definition: disp_default.c:144
#define DISP_WIDT_NODESLEFT
Definition: disp_default.c:94
#define SCIPallocBlockMemory(scip, ptr)
Definition: scip_mem.h:89
int SCIPgetNLPBranchCands(SCIP *scip)
Definition: scip_branch.c:428
SCIP_Real SCIPsyncstoreGetLastUpperbound(SCIP_SYNCSTORE *syncstore)
Definition: syncstore.c:268
#define DISP_WIDT_CURCONSS
Definition: disp_default.c:208
#define DISP_STRI_MAXDEPTH
Definition: disp_default.c:163
void SCIPdispInt(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, int val, int width)
Definition: disp.c:627
#define DISP_NAME_NEXTERNCANDS
Definition: disp_default.c:181
#define DISP_PRIO_CUTS
Definition: disp_default.c:233
#define DISP_HEAD_DEPTH
Definition: disp_default.c:151
#define DISP_STRI_CURROWS
Definition: disp_default.c:227
#define DISP_POSI_VARS
Definition: disp_default.c:194
#define DISP_WIDT_CURCOLS
Definition: disp_default.c:216
#define DISP_HEAD_PSEUDOOBJ
Definition: disp_default.c:271
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
Definition: scip_message.c:208
#define DISP_DESC_VARS
Definition: disp_default.c:190
#define DISP_NAME_LPCOND
Definition: disp_default.c:116
SCIP_DISP * SCIPfindDisp(SCIP *scip, const char *name)
Definition: scip_disp.c:97
SCIP_Real SCIPepsilon(SCIP *scip)
public methods for numerical tolerances
public methods for querying solving statistics
#define DISP_WIDT_ESTIMATE
Definition: disp_default.c:296
#define DISP_POSI_CONSS
Definition: disp_default.c:202
#define DISP_PRIO_ESTIMATE
Definition: disp_default.c:297
#define DISP_STRI_SEPAROUNDS
Definition: disp_default.c:243
public methods for the branch-and-bound tree
#define DISP_PRIO_TIME
Definition: disp_default.c:79
#define DISP_HEAD_CONCPRIMALBOUND
Definition: disp_default.c:335
#define DISP_POSI_LPITERATIONS
Definition: disp_default.c:105
#define DISP_STRI_NINFEASLEAVES
Definition: disp_default.c:398
#define DISP_PRIO_PRIMALBOUND
Definition: disp_default.c:329
#define DISP_WIDT_NEXTERNCANDS
Definition: disp_default.c:184
#define DISP_DESC_AVGDUALBOUND
Definition: disp_default.c:302
#define DISP_NAME_MEMTOTAL
Definition: disp_default.c:140
#define DISP_WIDT_GAP
Definition: disp_default.c:352
int SCIPgetNCutsApplied(SCIP *scip)
#define DISP_WIDT_CUTOFFBOUND
Definition: disp_default.c:344
#define DISP_NAME_AVGDUALBOUND
Definition: disp_default.c:301
#define DISP_WIDT_LPCOND
Definition: disp_default.c:119
#define DISP_NAME_PRIMALGAP
Definition: disp_default.c:365
const char * SCIPheurGetName(SCIP_HEUR *heur)
Definition: heur.c:1450
#define DISP_STRI_CONFLICTS
Definition: disp_default.c:259
#define DISP_POSI_PRIMALBOUND
Definition: disp_default.c:330
#define DISP_STRI_GAP
Definition: disp_default.c:355
#define DISP_WIDT_SOLFOUND
Definition: disp_default.c:62
#define DISP_WIDT_PLUNGEDEPTH
Definition: disp_default.c:168
#define DISP_NAME_PRIMALBOUND
Definition: disp_default.c:325
#define DISP_POSI_NEXTERNCANDS
Definition: disp_default.c:186
#define DISP_WIDT_NOBJLEAVES
Definition: disp_default.c:385
#define DISP_PRIO_STRONGBRANCHS
Definition: disp_default.c:265
#define DISP_DESC_NODESLEFT
Definition: disp_default.c:92
#define DISP_NAME_LPAVGITERS
Definition: disp_default.c:108
#define DISP_POSI_MEMUSED
Definition: disp_default.c:129
#define DISP_PRIO_NEXTERNCANDS
Definition: disp_default.c:185
#define DISP_PRIO_CONSS
Definition: disp_default.c:201
SCIP_Real SCIPgetDualbound(SCIP *scip)
#define DISP_PRIO_NINFEASLEAVES
Definition: disp_default.c:396
SCIP_STATUS SCIPgetStatus(SCIP *scip)
Definition: scip_general.c:483
#define DISP_STRI_CURCOLS
Definition: disp_default.c:219
#define DISP_PRIO_SOLFOUND
Definition: disp_default.c:63
#define DISP_POSI_GAP
Definition: disp_default.c:354
#define DISP_DESC_CURCONSS
Definition: disp_default.c:206
#define DISP_PRIO_GAP
Definition: disp_default.c:353
SCIP_RELAX * SCIPsolGetRelax(SCIP_SOL *sol)
Definition: sol.c:2685
type definitions for specific LP solvers interface
#define DISP_HEAD_PRIMALGAP
Definition: disp_default.c:367
SCIP_RETCODE SCIPincludeDispDefault(SCIP *scip)
#define DISP_WIDT_DUALBOUND
Definition: disp_default.c:312
#define NULL
Definition: lpi_spx1.cpp:164
SCIP_HEUR * SCIPsolGetHeur(SCIP_SOL *sol)
Definition: sol.c:2613
#define DISP_NAME_CONCSOLFOUND
Definition: disp_default.c:67
SCIP_Real SCIPgetSolTransObj(SCIP *scip, SCIP_SOL *sol)
Definition: scip_sol.c:1491
#define DISP_NAME_MEMUSED
Definition: disp_default.c:124
#define REALABS(x)
Definition: def.h:210
SCIP_Real SCIPgetLocalDualbound(SCIP *scip)
Definition: scip_prob.c:3574
#define DISP_NAME_CURROWS
Definition: disp_default.c:221
#define DISP_PRIO_CURCOLS
Definition: disp_default.c:217
#define DISP_POSI_CUTOFFBOUND
Definition: disp_default.c:346
#define DISP_STRI_CONCPRIMALBOUND
Definition: disp_default.c:339
int SCIPgetNLPRows(SCIP *scip)
Definition: scip_lp.c:626
#define DISP_NAME_CURDUALBOUND
Definition: disp_default.c:285
public methods for primal CIP solutions
#define DISP_STRI_LPITERATIONS
Definition: disp_default.c:106
const char * SCIPrelaxGetName(SCIP_RELAX *relax)
Definition: relax.c:542
#define DISP_DESC_PRIMALGAP
Definition: disp_default.c:366
#define DISP_PRIO_DUALBOUND
Definition: disp_default.c:313
#define SCIP_CALL(x)
Definition: def.h:393
SCIP_Real SCIPgetLowerbound(SCIP *scip)
#define DISP_NAME_DEPTH
Definition: disp_default.c:149
SCIP_Bool SCIPisPrimalboundSol(SCIP *scip)
SCIP_Longint SCIPgetNTotalNodes(SCIP *scip)
void SCIPdispTime(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, SCIP_Real val, int width)
Definition: disp.c:643
SCIP_Bool SCIPisFeasLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
#define DISP_PRIO_CONCDUALBOUND
Definition: disp_default.c:321
#define DISP_HEAD_PRIMALBOUND
Definition: disp_default.c:327
#define DISP_DESC_GAP
Definition: disp_default.c:350
#define DISP_WIDT_NNODES
Definition: disp_default.c:86
#define DISP_NAME_LPOBJ
Definition: disp_default.c:277
#define DISP_PRIO_LPAVGITERS
Definition: disp_default.c:112
#define DISP_STRI_CONCMEMUSED
Definition: disp_default.c:138
#define DISP_NAME_PSEUDOOBJ
Definition: disp_default.c:269
#define DISP_DESC_NFRAC
Definition: disp_default.c:174
#define DISP_DESC_CUTS
Definition: disp_default.c:230
#define DISP_HEAD_POOLSIZE
Definition: disp_default.c:247
#define DISP_DESC_NEXTERNCANDS
Definition: disp_default.c:182
#define DISP_WIDT_MEMUSED
Definition: disp_default.c:127
#define DISP_NAME_NSOLS
Definition: disp_default.c:373
#define DISP_POSI_CONCDUALBOUND
Definition: disp_default.c:322
#define DISP_DESC_CURCOLS
Definition: disp_default.c:214
SCIP_Bool SCIPhasCurrentNodeLP(SCIP *scip)
Definition: scip_lp.c:83
SCIP_SOLTYPE SCIPsolGetType(SCIP_SOL *sol)
Definition: sol.c:2675
#define DISP_HEAD_MAXDEPTH
Definition: disp_default.c:159
#define DISP_POSI_NOBJLEAVES
Definition: disp_default.c:387
#define DISP_PRIO_CONFLICTS
Definition: disp_default.c:257
#define DISP_DESC_CURDUALBOUND
Definition: disp_default.c:286
the function declarations for the synchronization store
#define DISP_STRI_NODESLEFT
Definition: disp_default.c:97
#define DISP_PRIO_LPOBJ
Definition: disp_default.c:281
#define DISP_DESC_CURROWS
Definition: disp_default.c:222
#define DISP_STRI_AVGDUALBOUND
Definition: disp_default.c:307
#define DISP_POSI_MEMTOTAL
Definition: disp_default.c:146
#define SCIP_Bool
Definition: def.h:93
#define DISP_HEAD_NINFEASLEAVES
Definition: disp_default.c:394
#define DISP_STRI_NEXTERNCANDS
Definition: disp_default.c:187
#define DISP_HEAD_MEMTOTAL
Definition: disp_default.c:142
SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)
Definition: scip_lp.c:168
#define DISP_STRI_NFRAC
Definition: disp_default.c:179
SCIP_RETCODE SCIPincludeDisp(SCIP *scip, const char *name, const char *desc, const char *header, SCIP_DISPSTATUS dispstatus, SCIP_DECL_DISPCOPY((*dispcopy)), SCIP_DECL_DISPFREE((*dispfree)), SCIP_DECL_DISPINIT((*dispinit)), SCIP_DECL_DISPEXIT((*dispexit)), SCIP_DECL_DISPINITSOL((*dispinitsol)), SCIP_DECL_DISPEXITSOL((*dispexitsol)), SCIP_DECL_DISPOUTPUT((*dispoutput)), SCIP_DISPDATA *dispdata, int width, int priority, int position, SCIP_Bool stripline)
Definition: scip_disp.c:55
#define DISP_STRI_ESTIMATE
Definition: disp_default.c:299
#define DISP_PRIO_MAXDEPTH
Definition: disp_default.c:161
#define DISP_NAME_CURCOLS
Definition: disp_default.c:213
#define DISP_POSI_NODESLEFT
Definition: disp_default.c:96
SCIP_SYNCSTORE * SCIPgetSyncstore(SCIP *scip)
int SCIPgetDepth(SCIP *scip)
Definition: scip_tree.c:670
#define DISP_NAME_MAXDEPTH
Definition: disp_default.c:157
public methods for concurrent solving mode
SCIP_Real SCIPgetGap(SCIP *scip)
#define DISP_PRIO_NFRAC
Definition: disp_default.c:177
#define DISP_DESC_POOLSIZE
Definition: disp_default.c:246
#define DISP_STRI_POOLSIZE
Definition: disp_default.c:251
#define DISP_DESC_CONCSOLFOUND
Definition: disp_default.c:68
#define DISP_HEAD_CONSS
Definition: disp_default.c:199
#define DISP_WIDT_CONCSOLFOUND
Definition: disp_default.c:70
#define DISP_PRIO_POOLSIZE
Definition: disp_default.c:249
#define DISP_HEAD_PLUNGEDEPTH
Definition: disp_default.c:167
#define DISP_NAME_CURCONSS
Definition: disp_default.c:205
#define DISP_NAME_ESTIMATE
Definition: disp_default.c:293
#define DISP_HEAD_CONCMEMUSED
Definition: disp_default.c:134
public methods for cuts and aggregation rows
#define DISP_POSI_CONCGAP
Definition: disp_default.c:362
#define DISP_WIDT_NFRAC
Definition: disp_default.c:176
#define DISP_NAME_CONSS
Definition: disp_default.c:197
#define DISP_PRIO_AVGDUALBOUND
Definition: disp_default.c:305
SCIP_Longint SCIPsyncstoreGetLastMemTotal(SCIP_SYNCSTORE *syncstore)
Definition: syncstore.c:312
#define DISP_WIDT_PRIMALGAP
Definition: disp_default.c:368
#define DISP_PRIO_VARS
Definition: disp_default.c:193
#define DISP_STRI_VARS
Definition: disp_default.c:195
#define DISP_WIDT_CURROWS
Definition: disp_default.c:224
#define DISP_HEAD_SOLFOUND
Definition: disp_default.c:61
#define DISP_WIDT_CONCPRIMALBOUND
Definition: disp_default.c:336
#define DISP_HEAD_TIME
Definition: disp_default.c:77
#define DISP_WIDT_CONCDUALBOUND
Definition: disp_default.c:320
#define DISP_POSI_CURCOLS
Definition: disp_default.c:218
static SCIP_DECL_DISPOUTPUT(SCIPdispOutputSolFound)
Definition: disp_default.c:446
#define DISP_DESC_SOLFOUND
Definition: disp_default.c:60
#define DISP_POSI_LPCOND
Definition: disp_default.c:121
SCIP_Longint SCIPgetNConflictConssApplied(SCIP *scip)
SCIP_Longint SCIPgetNObjlimLeaves(SCIP *scip)
#define DISP_POSI_MAXDEPTH
Definition: disp_default.c:162
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
#define DISP_DESC_NSOLS
Definition: disp_default.c:374
#define DISP_POSI_CONFLICTS
Definition: disp_default.c:258
void SCIPchgDispMode(SCIP_DISP *disp, SCIP_DISPMODE mode)
Definition: scip_disp.c:145
#define DISP_WIDT_LPOBJ
Definition: disp_default.c:280
helper functions for concurrent scip solvers
public methods for the LP relaxation, rows and columns
#define DISP_POSI_CURCONSS
Definition: disp_default.c:210
int SCIPgetNVars(SCIP *scip)
Definition: scip_prob.c:2000
#define DISP_NAME_NNODES
Definition: disp_default.c:83
SCIP_Real SCIPgetAvgDualbound(SCIP *scip)
#define DISP_POSI_NINFEASLEAVES
Definition: disp_default.c:397
#define DISP_POSI_DUALBOUND
Definition: disp_default.c:314
int SCIPsyncstoreGetLastNSols(SCIP_SYNCSTORE *syncstore)
Definition: syncstore.c:290
#define DISP_WIDT_TIME
Definition: disp_default.c:78
#define DISP_NAME_CUTOFFBOUND
Definition: disp_default.c:341
#define DISP_STRI_PRIMALBOUND
Definition: disp_default.c:331
public methods for branching rule plugins and branching
#define DISP_NAME_NINFEASLEAVES
Definition: disp_default.c:392
general public methods
#define DISP_DESC_CONCPRIMALBOUND
Definition: disp_default.c:334
SCIP_Longint SCIPgetMemTotal(SCIP *scip)
Definition: scip_mem.c:113
SCIP_Real SCIPgetLPObjval(SCIP *scip)
Definition: scip_lp.c:247
SCIP_SOL * SCIPgetBestSol(SCIP *scip)
Definition: scip_sol.c:2313
#define DISP_POSI_NNODES
Definition: disp_default.c:88
#define DISP_WIDT_CONCGAP
Definition: disp_default.c:360
#define DISP_POSI_LPOBJ
Definition: disp_default.c:282
SCIP_Real SCIPgetConcurrentGap(SCIP *scip)
Definition: concurrent.c:335
public methods for solutions
SCIP_Longint SCIPgetMemUsed(SCIP *scip)
Definition: scip_mem.c:100
#define DISP_DESC_CUTOFFBOUND
Definition: disp_default.c:342
SCIP_Real SCIPgetConcurrentDualbound(SCIP *scip)
Definition: concurrent.c:305
#define DISP_POSI_SOLFOUND
Definition: disp_default.c:64
#define DISP_WIDT_POOLSIZE
Definition: disp_default.c:248
int SCIPgetNConss(SCIP *scip)
Definition: scip_prob.c:3050
#define DISP_PRIO_LPITERATIONS
Definition: disp_default.c:104
#define DISP_PRIO_LPCOND
Definition: disp_default.c:120
#define DISP_STRI_LPOBJ
Definition: disp_default.c:283
#define DISP_DESC_MEMUSED
Definition: disp_default.c:125
#define DISP_DESC_TIME
Definition: disp_default.c:76
void SCIPdispSetData(SCIP_DISP *disp, SCIP_DISPDATA *dispdata)
Definition: disp.c:324
#define DISP_POSI_ESTIMATE
Definition: disp_default.c:298
#define DISP_STRI_CURDUALBOUND
Definition: disp_default.c:291
#define DISP_POSI_CONCPRIMALBOUND
Definition: disp_default.c:338
public methods for message output
#define DISP_STRI_CUTS
Definition: disp_default.c:235
#define DISP_WIDT_STRONGBRANCHS
Definition: disp_default.c:264
SCIP_Real SCIPretransformObj(SCIP *scip, SCIP_Real obj)
Definition: scip_sol.c:1576
#define DISP_PRIO_NNODES
Definition: disp_default.c:87
#define DISP_STRI_NNODES
Definition: disp_default.c:89
SCIP_HEUR * SCIPgetSolHeur(SCIP *scip, SCIP_SOL *sol)
Definition: scip_sol.c:1684
#define SCIP_Real
Definition: def.h:186
public methods for relaxation handlers
#define DISP_DESC_MAXDEPTH
Definition: disp_default.c:158
#define DISP_PRIO_PSEUDOOBJ
Definition: disp_default.c:273
char SCIPheurGetDispchar(SCIP_HEUR *heur)
Definition: heur.c:1470
#define DISP_STRI_CONCSOLFOUND
Definition: disp_default.c:73
#define DISP_PRIO_CURDUALBOUND
Definition: disp_default.c:289
public methods for message handling
#define DISP_STRI_PLUNGEDEPTH
Definition: disp_default.c:171
#define DISP_DESC_NINFEASLEAVES
Definition: disp_default.c:393
#define DISP_DESC_NOBJLEAVES
Definition: disp_default.c:383
int SCIPgetNPoolCuts(SCIP *scip)
Definition: scip_cut.c:420
#define SCIP_INVALID
Definition: def.h:206
SCIP_Real SCIPgetLocalOrigEstimate(SCIP *scip)
Definition: scip_prob.c:3535
#define DISP_PRIO_MEMUSED
Definition: disp_default.c:128
#define DISP_HEAD_CONCGAP
Definition: disp_default.c:359
#define DISP_POSI_DEPTH
Definition: disp_default.c:154
#define DISP_DESC_CONSS
Definition: disp_default.c:198
#define SCIP_Longint
Definition: def.h:171
#define DISP_HEAD_NNODES
Definition: disp_default.c:85
#define DISP_HEAD_AVGDUALBOUND
Definition: disp_default.c:303
#define DISP_HEAD_NODESLEFT
Definition: disp_default.c:93
#define DISP_NAME_LPITERATIONS
Definition: disp_default.c:100
#define DISP_WIDT_PRIMALBOUND
Definition: disp_default.c:328
SCIP_OBJSENSE SCIPgetObjsense(SCIP *scip)
Definition: scip_prob.c:1233
#define DISP_POSI_POOLSIZE
Definition: disp_default.c:250
#define DISP_STRI_LPCOND
Definition: disp_default.c:122
#define DISP_PRIO_CURROWS
Definition: disp_default.c:225
#define DISP_PRIO_PLUNGEDEPTH
Definition: disp_default.c:169
SCIP_DISPDATA * SCIPdispGetData(SCIP_DISP *disp)
Definition: disp.c:314
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
#define DISP_HEAD_CURROWS
Definition: disp_default.c:223
#define DISP_HEAD_LPCOND
Definition: disp_default.c:118
#define DISP_POSI_CURDUALBOUND
Definition: disp_default.c:290
#define DISP_WIDT_PSEUDOOBJ
Definition: disp_default.c:272
int SCIPgetNLPCols(SCIP *scip)
Definition: scip_lp.c:527
#define DISP_DESC_CONFLICTS
Definition: disp_default.c:254
#define DISP_PRIO_SEPAROUNDS
Definition: disp_default.c:241
#define DISP_NAME_CONCMEMUSED
Definition: disp_default.c:132
SCIP_Real SCIPgetUpperbound(SCIP *scip)
public methods for primal heuristics
#define DISP_NAME_CONCGAP
Definition: disp_default.c:357
int SCIPgetNExternBranchCands(SCIP *scip)
Definition: scip_branch.c:543
#define DISP_WIDT_NINFEASLEAVES
Definition: disp_default.c:395
SCIP_Real SCIPgetPseudoObjval(SCIP *scip)
Definition: scip_lp.c:333
#define DISP_NAME_SOLFOUND
Definition: disp_default.c:59
#define DISP_DESC_LPAVGITERS
Definition: disp_default.c:109
#define DISP_DESC_CONCGAP
Definition: disp_default.c:358
#define DISP_WIDT_CONSS
Definition: disp_default.c:200
int SCIPgetNEnabledConss(SCIP *scip)
#define DISP_STRI_LPAVGITERS
Definition: disp_default.c:114
SCIP_Longint SCIPgetNNodes(SCIP *scip)
const char * SCIPdispGetName(SCIP_DISP *disp)
Definition: disp.c:335
public methods for global and local (sub)problems
SCIP_Longint SCIPgetNInfeasibleLeaves(SCIP *scip)
#define DISP_STRI_STRONGBRANCHS
Definition: disp_default.c:267
#define DISP_POSI_PLUNGEDEPTH
Definition: disp_default.c:170
#define DISP_HEAD_NFRAC
Definition: disp_default.c:175
#define DISP_DESC_LPITERATIONS
Definition: disp_default.c:101
#define DISP_HEAD_GAP
Definition: disp_default.c:351
static SCIP_Bool isDisplaySol(SCIP *scip, SCIP_SOL *sol)
Definition: disp_default.c:436
#define DISP_HEAD_LPITERATIONS
Definition: disp_default.c:102
#define DISP_STRI_CONCDUALBOUND
Definition: disp_default.c:323
#define DISP_NAME_VARS
Definition: disp_default.c:189
#define DISP_HEAD_MEMUSED
Definition: disp_default.c:126
#define DISP_STRI_TIME
Definition: disp_default.c:81
#define DISP_DESC_PSEUDOOBJ
Definition: disp_default.c:270
#define DISP_HEAD_NSOLS
Definition: disp_default.c:375
#define DISP_PRIO_PRIMALGAP
Definition: disp_default.c:369
#define DISP_HEAD_DUALBOUND
Definition: disp_default.c:311
#define DISP_DESC_PRIMALBOUND
Definition: disp_default.c:326
public methods for display handler plugins
#define DISP_HEAD_SEPAROUNDS
Definition: disp_default.c:239
#define DISP_STRI_CUTOFFBOUND
Definition: disp_default.c:347
#define DISP_HEAD_CONFLICTS
Definition: disp_default.c:255
#define DISP_POSI_CURROWS
Definition: disp_default.c:226
int SCIPgetNSepaRounds(SCIP *scip)
#define DISP_HEAD_ESTIMATE
Definition: disp_default.c:295
#define DISP_HEAD_CUTS
Definition: disp_default.c:231
#define DISP_STRI_DUALBOUND
Definition: disp_default.c:315
#define DISP_HEAD_CURCOLS
Definition: disp_default.c:215