Scippy

SCIP

Solving Constraint Integer Programs

disp.c
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the program and library */
4 /* SCIP --- Solving Constraint Integer Programs */
5 /* */
6 /* Copyright (C) 2002-2017 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SCIP is distributed under the terms of the ZIB Academic License. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SCIP; see the file COPYING. If not email to scip@zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file disp.c
17  * @brief methods and datastructures for displaying runtime statistics
18  * @author Tobias Achterberg
19  * @author Timo Berthold
20  */
21 
22 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
23 
24 #include <stdio.h>
25 #include <assert.h>
26 #include <string.h>
27 
28 #include "scip/def.h"
29 #include "blockmemshell/memory.h"
30 #include "scip/set.h"
31 #include "scip/stat.h"
32 #include "scip/scip.h"
33 #include "scip/disp.h"
34 #include "scip/pub_message.h"
35 #include "scip/pub_misc.h"
36 #include "scip/syncstore.h"
37 #include "scip/struct_disp.h"
38 
39 
40 
41 /*
42  * display column methods
43  */
44 
45 /** parameter change information method to autoselect display columns again */
46 SCIP_DECL_PARAMCHGD(SCIPparamChgdDispActive)
47 { /*lint --e{715}*/
48  /* automatically select the now active display columns */
50 
51  return SCIP_OKAY;
52 }
53 
54 /** copies the given display to a new scip */
56  SCIP_DISP* disp, /**< display column */
57  SCIP_SET* set /**< SCIP_SET of SCIP to copy to */
58  )
59 {
60  assert(disp != NULL);
61  assert(set != NULL);
62  assert(set->scip != NULL);
63 
64  if( disp->dispcopy != NULL )
65  {
66  SCIPsetDebugMsg(set, "including display column %s in subscip %p\n", SCIPdispGetName(disp), (void*)set->scip);
67  SCIP_CALL( disp->dispcopy(set->scip, disp) );
68  }
69  return SCIP_OKAY;
70 }
71 
72 /** creates a display column */
74  SCIP_DISP** disp, /**< pointer to store display column */
75  SCIP_SET* set, /**< global SCIP settings */
76  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
77  BMS_BLKMEM* blkmem, /**< block memory for parameter settings */
78  const char* name, /**< name of display column */
79  const char* desc, /**< description of display column */
80  const char* header, /**< head line of display column */
81  SCIP_DISPSTATUS dispstatus, /**< display activation status of display column */
82  SCIP_DECL_DISPCOPY ((*dispcopy)), /**< copy method of display column or NULL if you don't want to copy your plugin into sub-SCIPs */
83  SCIP_DECL_DISPFREE ((*dispfree)), /**< destructor of display column */
84  SCIP_DECL_DISPINIT ((*dispinit)), /**< initialize display column */
85  SCIP_DECL_DISPEXIT ((*dispexit)), /**< deinitialize display column */
86  SCIP_DECL_DISPINITSOL ((*dispinitsol)), /**< solving process initialization method of display column */
87  SCIP_DECL_DISPEXITSOL ((*dispexitsol)), /**< solving process deinitialization method of display column */
88  SCIP_DECL_DISPOUTPUT ((*dispoutput)), /**< output method */
89  SCIP_DISPDATA* dispdata, /**< display column data */
90  int width, /**< width of display column (no. of chars used) */
91  int priority, /**< priority of display column */
92  int position, /**< relative position of display column */
93  SCIP_Bool stripline /**< should the column be separated with a line from its right neighbor? */
94  )
95 {
96  char paramname[SCIP_MAXSTRLEN];
97  char paramdesc[SCIP_MAXSTRLEN];
98 
99  assert(disp != NULL);
100  assert(name != NULL);
101  assert(desc != NULL);
102  assert(header != NULL);
103  assert(dispoutput != NULL);
104  assert(width >= 0);
105 
106  SCIP_ALLOC( BMSallocMemory(disp) );
107  SCIP_ALLOC( BMSduplicateMemoryArray(&(*disp)->name, name, strlen(name)+1) );
108  SCIP_ALLOC( BMSduplicateMemoryArray(&(*disp)->desc, desc, strlen(desc)+1) );
109  SCIP_ALLOC( BMSduplicateMemoryArray(&(*disp)->header, header, strlen(header)+1) );
110  (*disp)->dispstatus = dispstatus;
111  (*disp)->dispcopy = dispcopy;
112  (*disp)->dispfree = dispfree;
113  (*disp)->dispinit = dispinit;
114  (*disp)->dispexit = dispexit;
115  (*disp)->dispinitsol = dispinitsol;
116  (*disp)->dispexitsol = dispexitsol;
117  (*disp)->dispoutput = dispoutput;
118  (*disp)->dispdata = dispdata;
119  (*disp)->width = width;
120  (*disp)->priority = priority;
121  (*disp)->position = position;
122  (*disp)->stripline = stripline;
123  (*disp)->initialized = FALSE;
124  (*disp)->active = (dispstatus == SCIP_DISPSTATUS_ON);
125  (*disp)->mode = SCIP_DISPMODE_DEFAULT;
126 
127  /* add parameters */
128  (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "display/%s/active", name);
129  (void) SCIPsnprintf(paramdesc, SCIP_MAXSTRLEN, "display activation status of display column <%s> (0: off, 1: auto, 2:on)", name);
130  SCIP_CALL( SCIPsetAddIntParam(set, messagehdlr, blkmem, paramname, paramdesc,
131  (int*)(&(*disp)->dispstatus), FALSE, (int)dispstatus, 0, 2, SCIPparamChgdDispActive, NULL) );
132 
133  return SCIP_OKAY;
134 }
135 
136 /** frees memory of display column */
138  SCIP_DISP** disp, /**< pointer to display column data structure */
139  SCIP_SET* set /**< global SCIP settings */
140  )
141 {
142  assert(disp != NULL);
143  assert(*disp != NULL);
144  assert(!(*disp)->initialized);
145  assert(set != NULL);
146 
147  /* call destructor of display column */
148  if( (*disp)->dispfree != NULL )
149  {
150  SCIP_CALL( (*disp)->dispfree(set->scip, *disp) );
151  }
152 
153  BMSfreeMemoryArray(&(*disp)->name);
154  BMSfreeMemoryArray(&(*disp)->desc);
155  BMSfreeMemoryArray(&(*disp)->header);
156  BMSfreeMemory(disp);
157 
158  return SCIP_OKAY;
159 }
160 
161 /** initializes display column */
163  SCIP_DISP* disp, /**< display column */
164  SCIP_SET* set /**< global SCIP settings */
165  )
166 {
167  assert(disp != NULL);
168  assert(set != NULL);
169 
170  if( disp->initialized )
171  {
172  SCIPerrorMessage("display column <%s> already initialized\n", disp->name);
173  return SCIP_INVALIDCALL;
174  }
175 
176  if( disp->dispinit != NULL )
177  {
178  SCIP_CALL( disp->dispinit(set->scip, disp) );
179  }
180  disp->initialized = TRUE;
181 
182  return SCIP_OKAY;
183 }
184 
185 /** deinitializes display column */
187  SCIP_DISP* disp, /**< display column */
188  SCIP_SET* set /**< global SCIP settings */
189  )
190 {
191  assert(disp != NULL);
192  assert(set != NULL);
193 
194  if( !disp->initialized )
195  {
196  SCIPerrorMessage("display column <%s> not initialized\n", disp->name);
197  return SCIP_INVALIDCALL;
198  }
199 
200  if( disp->dispexit != NULL )
201  {
202  SCIP_CALL( disp->dispexit(set->scip, disp) );
203  }
204  disp->initialized = FALSE;
205 
206  return SCIP_OKAY;
207 }
208 
209 /** informs display column that the branch and bound process is being started */
211  SCIP_DISP* disp, /**< display column */
212  SCIP_SET* set /**< global SCIP settings */
213  )
214 {
215  assert(disp != NULL);
216  assert(set != NULL);
217 
218  /* call solving process initialization method of display column */
219  if( disp->dispinitsol != NULL )
220  {
221  SCIP_CALL( disp->dispinitsol(set->scip, disp) );
222  }
223 
224  return SCIP_OKAY;
225 }
226 
227 /** informs display column that the branch and bound process data is being freed */
229  SCIP_DISP* disp, /**< display column */
230  SCIP_SET* set /**< global SCIP settings */
231  )
232 {
233  assert(disp != NULL);
234  assert(set != NULL);
235 
236  /* call solving process deinitialization method of display column */
237  if( disp->dispexitsol != NULL )
238  {
239  SCIP_CALL( disp->dispexitsol(set->scip, disp) );
240  }
241 
242  return SCIP_OKAY;
243 }
244 
245 /** output display column to screen */
247  SCIP_DISP* disp, /**< display column */
248  SCIP_SET* set, /**< global SCIP settings */
249  FILE* file /**< output file (or NULL for standard output) */
250  )
251 {
252  assert(disp != NULL);
253  assert(disp->dispoutput != NULL);
254  assert(set != NULL);
255 
256  SCIP_CALL( disp->dispoutput(set->scip, disp, file) );
257 
258  return SCIP_OKAY;
259 }
260 
261 /** gets user data of display column */
263  SCIP_DISP* disp /**< display column */
264  )
265 {
266  assert(disp != NULL);
267 
268  return disp->dispdata;
269 }
270 
271 /** sets user data of display column; user has to free old data in advance! */
273  SCIP_DISP* disp, /**< display column */
274  SCIP_DISPDATA* dispdata /**< new display column user data */
275  )
276 {
277  assert(disp != NULL);
278 
279  disp->dispdata = dispdata;
280 }
281 
282 /** gets name of display column */
283 const char* SCIPdispGetName(
284  SCIP_DISP* disp /**< display column */
285  )
286 {
287  assert(disp != NULL);
288 
289  return disp->name;
290 }
291 
292 /** gets description of display column */
293 const char* SCIPdispGetDesc(
294  SCIP_DISP* disp /**< display column */
295  )
296 {
297  assert(disp != NULL);
298 
299  return disp->desc;
300 }
301 
302 /** gets head line of display column */
303 const char* SCIPdispGetHeader(
304  SCIP_DISP* disp /**< display column */
305  )
306 {
307  assert(disp != NULL);
308 
309  return disp->header;
310 }
311 
312 /** gets width of display column */
314  SCIP_DISP* disp /**< display column */
315  )
316 {
317  assert(disp != NULL);
318 
319  return disp->width;
320 }
321 
322 /** gets priority of display column */
324  SCIP_DISP* disp /**< display column */
325  )
326 {
327  assert(disp != NULL);
328 
329  return disp->priority;
330 }
331 
332 /** gets position of display column */
334  SCIP_DISP* disp /**< display column */
335  )
336 {
337  assert(disp != NULL);
338 
339  return disp->position;
340 }
341 
342 /** gets status of display column */
344  SCIP_DISP* disp /**< display column */
345  )
346 {
347  assert(disp != NULL);
348 
349  return disp->dispstatus;
350 }
351 
352 /** is display column initialized? */
354  SCIP_DISP* disp /**< display column */
355  )
356 {
357  assert(disp != NULL);
358 
359  return disp->initialized;
360 }
361 
362 /** prints one line of output with the active display columns */
364  SCIP_SET* set, /**< global SCIP settings */
365  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
366  SCIP_STAT* stat, /**< problem statistics data */
367  FILE* file, /**< output file (or NULL for standard output) */
368  SCIP_Bool forcedisplay, /**< should the line be printed without regarding frequency? */
369  SCIP_Bool endline /**< should the line be terminated with a newline symbol? */
370  )
371 {
372  assert(set != NULL);
373  assert(set->disp_freq >= -1);
374  assert(set->disp_headerfreq >= -1);
375  assert(stat != NULL);
376 
377  if( (SCIP_VERBLEVEL)set->disp_verblevel < SCIP_VERBLEVEL_NORMAL || set->disp_freq == -1 )
378  return SCIP_OKAY;
379 
380  if( forcedisplay
381  || (stat->nnodes != stat->lastdispnode
382  && set->disp_freq > 0
383  && (stat->nnodes % set->disp_freq == 0 || stat->nnodes == 1)) )
384  {
385  int i;
386  int j;
387  SCIP_Bool stripline;
388 
389  /* display header line */
390  if( (set->disp_headerfreq == 0 && stat->ndisplines == 0)
391  || (set->disp_headerfreq > 0 && stat->ndisplines % set->disp_headerfreq == 0) )
392  {
393  int fillspace;
394 
395  stripline = FALSE;
396  for( i = 0; i < set->ndisps; ++i )
397  {
398  assert(set->disps[i] != NULL);
399  if( set->disps[i]->active )
400  {
401  if( stripline )
402  SCIPmessageFPrintInfo(messagehdlr, file, "|");
403  fillspace = set->disps[i]->width - (int)strlen(set->disps[i]->header);
404  for( j = 0; j < (fillspace)/2; ++j )
405  SCIPmessageFPrintInfo(messagehdlr, file, " ");
406  SCIPmessageFPrintInfo(messagehdlr, file, "%s", (const char*)set->disps[i]->header);
407  for( j = 0; j < (fillspace+1)/2; ++j )
408  SCIPmessageFPrintInfo(messagehdlr, file, " ");
409  stripline = set->disps[i]->stripline;
410  }
411  }
412  SCIPmessageFPrintInfo(messagehdlr, file, "\n");
413  }
414 
415  /* display node information line */
416  stripline = FALSE;
417  for( i = 0; i < set->ndisps; ++i )
418  {
419  assert(set->disps[i] != NULL);
420  if( set->disps[i]->active )
421  {
422  if( stripline )
423  SCIPmessageFPrintInfo(messagehdlr, file, "|");
424  SCIP_CALL( SCIPdispOutput(set->disps[i], set, file) );
425  stripline = set->disps[i]->stripline;
426  }
427  }
428  if( endline )
429  {
430  SCIPmessageFPrintInfo(messagehdlr, file, "\n");
431  }
432  fflush(stdout);
433 
434  stat->lastdispnode = stat->nnodes;
435  stat->ndisplines++;
436  }
437 
438  return SCIP_OKAY;
439 }
440 
441 /** comparison method for display columns */
442 static
444 { /*lint --e{715}*/
445  return ((SCIP_DISP*)elem2)->priority - ((SCIP_DISP*)elem1)->priority;
446 }
447 
448 /** activates all display lines fitting in the display w.r. to priority */
450  SCIP_SET* set /**< global SCIP settings */
451  )
452 {
453  SCIP_DISP** disps;
454  SCIP_SYNCSTORE* syncstore;
455  SCIP_DISPMODE mode;
456  int totalwidth;
457  int width;
458  int i;
459 
460  assert(set != NULL);
461 
462  syncstore = SCIPgetSyncstore(set->scip);
463  assert(syncstore != NULL);
464 
465  /* sort display columns w.r. to their priority */
466  SCIP_ALLOC( BMSduplicateMemoryArray(&disps, set->disps, set->ndisps) );
467  SCIPsortPtr((void**)disps, dispComp, set->ndisps);
468 
469  totalwidth = 0;
470 
471  if( SCIPsyncstoreIsInitialized(syncstore) )
473  else
474  mode = SCIP_DISPMODE_DEFAULT;
475 
476  /* first activate all columns with display status ON */
477  for( i = 0; i < set->ndisps; ++i )
478  {
479  width = disps[i]->width;
480  if( disps[i]->stripline )
481  width++;
482  if( disps[i]->dispstatus == SCIP_DISPSTATUS_ON && (disps[i]->mode & mode) )
483  {
484  disps[i]->active = TRUE;
485  totalwidth += width;
486  }
487  else
488  disps[i]->active = FALSE;
489  }
490 
491  /* beginning with highest priority display column, activate AUTO columns as long as it fits into display width */
492  for( i = 0; i < set->ndisps; ++i )
493  {
494  if( disps[i]->dispstatus == SCIP_DISPSTATUS_AUTO )
495  {
496  assert(!disps[i]->active);
497 
498  width = disps[i]->width;
499  if( disps[i]->stripline )
500  width++;
501  if( totalwidth + width <= set->disp_width && (disps[i]->mode & mode) )
502  {
503  disps[i]->active = TRUE;
504  totalwidth += width;
505  }
506  }
507  }
508 
509  /* free temporary memory */
510  BMSfreeMemoryArray(&disps);
511 
512  return SCIP_OKAY;
513 }
514 
515 /** changes the display column mode */
517  SCIP_DISP* disp, /**< display column */
518  SCIP_DISPMODE mode /**< the display column mode */
519  )
520 {
521  disp->mode = mode;
522 }
523 
524 static
525 const char decpowerchar[] = {' ', 'k', 'M', 'G', 'T', 'P', 'E'};
526 #define MAXDECPOWER 6
527 
528 /** displays a long integer in decimal form fitting in a given width */
530  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
531  FILE* file, /**< output stream */
532  SCIP_Longint val, /**< value to display */
533  int width /**< width to fit into */
534  )
535 {
536  assert(width >= 1);
537 
538  if( width == 1 )
539  {
540  if( val < 0 )
541  SCIPmessageFPrintInfo(messagehdlr, file, "-");
542  else if( val < 10 )
543  SCIPmessageFPrintInfo(messagehdlr, file, "%" SCIP_LONGINT_FORMAT, val);
544  else
545  SCIPmessageFPrintInfo(messagehdlr, file, "+");
546  }
547  else
548  {
549  char format[SCIP_MAXSTRLEN];
550  SCIP_Longint maxval;
551  int decpower;
552  int i;
553 
554  maxval = 1;
555  for( i = 0; i < width-1; ++i )
556  maxval *= 10;
557  if( val < 0 )
558  maxval /= 10;
559  decpower = 0;
560  while( ABS(val) >= maxval && decpower < MAXDECPOWER )
561  {
562  decpower++;
563  val /= 1000;
564  }
565  (void) SCIPsnprintf(format, SCIP_MAXSTRLEN, "%%%d" SCIP_LONGINT_FORMAT "%c", width-1, decpowerchar[decpower]);
566 
567  if( width == 2 && val < 0 )
568  SCIPmessageFPrintInfo(messagehdlr, file, "-%c", decpowerchar[decpower]);
569  else
570  SCIPmessageFPrintInfo(messagehdlr, file, (const char*)format, val);
571  }
572 }
573 
574 /** displays an integer in decimal form fitting in a given width */
576  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
577  FILE* file, /**< output stream */
578  int val, /**< value to display */
579  int width /**< width to fit into */
580  )
581 {
582  SCIPdispLongint(messagehdlr, file, (SCIP_Longint)val, width);
583 }
584 
585 
586 static
587 const char timepowerchar[] = {'s', 'm', 'h', 'd', 'y'};
588 const SCIP_Real timepowerval[] = {1.0, 60.0, 60.0, 24.0, 365.0};
589 #define MAXTIMEPOWER 4
590 
591 /** displays a time value fitting in a given width */
593  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
594  FILE* file, /**< output stream */
595  SCIP_Real val, /**< value in seconds to display */
596  int width /**< width to fit into */
597  )
598 {
599  assert(width >= 1);
600 
601  if( width == 1 )
602  {
603  if( val < 0.0 )
604  SCIPmessageFPrintInfo(messagehdlr, file, "-");
605  else if( val < 10.0 )
606  SCIPmessageFPrintInfo(messagehdlr, file, "%.0f", val);
607  else
608  SCIPmessageFPrintInfo(messagehdlr, file, "+");
609  }
610  else
611  {
612  char format[SCIP_MAXSTRLEN];
613  SCIP_Longint maxval;
614  int timepower;
615  int i;
616 
617  maxval = 1;
618  for( i = 0; i < width-1; ++i )
619  maxval *= 10;
620  if( val < 0.0 )
621  maxval /= 10;
622  timepower = 0;
623  while( REALABS(val) + 0.5 >= maxval && timepower < MAXTIMEPOWER )
624  {
625  timepower++;
626  val /= timepowerval[timepower];
627  }
628  if( REALABS(val) + 0.05 < maxval/100.0 )
629  (void) SCIPsnprintf(format, SCIP_MAXSTRLEN, "%%%d.1f%c", width-1, timepowerchar[timepower]);
630  else
631  (void) SCIPsnprintf(format, SCIP_MAXSTRLEN, "%%%d.0f%c", width-1, timepowerchar[timepower]);
632 
633  if( width == 2 && val < 0.0 )
634  SCIPmessageFPrintInfo(messagehdlr, file, "-%c", timepowerchar[timepower]);
635  else
636  SCIPmessageFPrintInfo(messagehdlr, file, (const char*)format, val);
637  }
638 }
void SCIPdispChgMode(SCIP_DISP *disp, SCIP_DISPMODE mode)
Definition: disp.c:516
char * name
Definition: struct_disp.h:38
SCIP_RETCODE SCIPdispInit(SCIP_DISP *disp, SCIP_SET *set)
Definition: disp.c:162
#define SCIP_DECL_DISPINITSOL(x)
Definition: type_disp.h:106
SCIP_Bool initialized
Definition: struct_disp.h:54
struct SCIP_DispData SCIP_DISPDATA
Definition: type_disp.h:62
SCIP_RETCODE SCIPdispInitsol(SCIP_DISP *disp, SCIP_SET *set)
Definition: disp.c:210
SCIP_DISPSTATUS SCIPdispGetStatus(SCIP_DISP *disp)
Definition: disp.c:343
SCIP_RETCODE SCIPdispAutoActivate(SCIP_SET *set)
Definition: disp.c:449
data structures for displaying runtime statistics
SCIP_RETCODE SCIPdispPrintLine(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, FILE *file, SCIP_Bool forcedisplay, SCIP_Bool endline)
Definition: disp.c:363
SCIP_RETCODE SCIPdispOutput(SCIP_DISP *disp, SCIP_SET *set, FILE *file)
Definition: disp.c:246
#define SCIP_MAXSTRLEN
Definition: def.h:259
SCIP_RETCODE SCIPdispFree(SCIP_DISP **disp, SCIP_SET *set)
Definition: disp.c:137
#define MAXDECPOWER
Definition: disp.c:526
void SCIPdispLongint(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, SCIP_Longint val, int width)
Definition: disp.c:529
int SCIPdispGetWidth(SCIP_DISP *disp)
Definition: disp.c:313
char * header
Definition: struct_disp.h:40
enum SCIP_DispMode SCIP_DISPMODE
Definition: type_disp.h:59
SCIP_RETCODE SCIPdispExit(SCIP_DISP *disp, SCIP_SET *set)
Definition: disp.c:186
const SCIP_Real timepowerval[]
Definition: disp.c:588
int position
Definition: struct_disp.h:51
#define FALSE
Definition: def.h:64
int SCIPsnprintf(char *t, int len, const char *s,...)
Definition: misc.c:10011
#define TRUE
Definition: def.h:63
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
int SCIPdispGetPriority(SCIP_DISP *disp)
Definition: disp.c:323
enum SCIP_VerbLevel SCIP_VERBLEVEL
Definition: type_message.h:48
static GRAPHNODE ** active
const char * SCIPdispGetDesc(SCIP_DISP *disp)
Definition: disp.c:293
SCIP_RETCODE SCIPdispCreate(SCIP_DISP **disp, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, 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: disp.c:73
int ndisplines
Definition: struct_stat.h:216
SCIP_Longint lastdispnode
Definition: struct_stat.h:99
#define BMSfreeMemory(ptr)
Definition: memory.h:127
void SCIPdispInt(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, int val, int width)
Definition: disp.c:575
#define SCIP_DECL_DISPCOPY(x)
Definition: type_disp.h:71
SCIP_RETCODE SCIPdispCopyInclude(SCIP_DISP *disp, SCIP_SET *set)
Definition: disp.c:55
#define SCIP_DECL_DISPINIT(x)
Definition: type_disp.h:87
char * desc
Definition: struct_disp.h:39
#define BMSfreeMemoryArray(ptr)
Definition: memory.h:129
SCIP_DISPMODE mode
Definition: struct_disp.h:56
#define SCIPerrorMessage
Definition: pub_message.h:45
SCIP_Bool SCIPsyncstoreIsInitialized(SCIP_SYNCSTORE *syncstore)
Definition: syncstore.c:776
SCIP_RETCODE SCIPdispExitsol(SCIP_DISP *disp, SCIP_SET *set)
Definition: disp.c:228
SCIP_Bool SCIPdispIsInitialized(SCIP_DISP *disp)
Definition: disp.c:353
const char * SCIPdispGetHeader(SCIP_DISP *disp)
Definition: disp.c:303
#define REALABS(x)
Definition: def.h:173
int priority
Definition: struct_disp.h:50
void SCIPsortPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
internal methods for global SCIP settings
#define SCIP_CALL(x)
Definition: def.h:350
static SCIP_DECL_SORTPTRCOMP(dispComp)
Definition: disp.c:443
void SCIPdispTime(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, SCIP_Real val, int width)
Definition: disp.c:592
SCIP_RETCODE SCIPsetAddIntParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int *valueptr, SCIP_Bool isadvanced, int defaultvalue, int minvalue, int maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: set.c:2813
#define BMSduplicateMemoryArray(ptr, source, num)
Definition: memory.h:125
the function declarations for the synchronization store
public data structures and miscellaneous methods
int SCIPdispGetPosition(SCIP_DISP *disp)
Definition: disp.c:333
#define SCIP_Bool
Definition: def.h:61
#define SCIP_DECL_DISPFREE(x)
Definition: type_disp.h:79
SCIP_DISPDATA * dispdata
Definition: struct_disp.h:48
SCIP_RETCODE SCIPautoselectDisps(SCIP *scip)
Definition: scip.c:9428
SCIP_SYNCSTORE * SCIPgetSyncstore(SCIP *scip)
Definition: scip.c:42011
#define SCIPsetDebugMsg
Definition: set.h:1913
SCIP_DECL_PARAMCHGD(SCIPparamChgdDispActive)
Definition: disp.c:46
#define MAXTIMEPOWER
Definition: disp.c:589
#define SCIP_DECL_DISPEXITSOL(x)
Definition: type_disp.h:117
#define SCIP_DECL_DISPEXIT(x)
Definition: type_disp.h:95
void SCIPdispSetData(SCIP_DISP *disp, SCIP_DISPDATA *dispdata)
Definition: disp.c:272
static const char decpowerchar[]
Definition: disp.c:525
public methods for message output
SCIP_DISPSTATUS dispstatus
Definition: struct_disp.h:52
void SCIPmessageFPrintInfo(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *formatstr,...)
Definition: message.c:608
enum SCIP_DispStatus SCIP_DISPSTATUS
Definition: type_disp.h:50
#define SCIP_Real
Definition: def.h:149
internal methods for problem statistics
#define BMSallocMemory(ptr)
Definition: memory.h:101
#define SCIP_Longint
Definition: def.h:134
SCIP_DISPDATA * SCIPdispGetData(SCIP_DISP *disp)
Definition: disp.c:262
static const char timepowerchar[]
Definition: disp.c:587
common defines and data types used in all packages of SCIP
SCIP_Longint nnodes
Definition: struct_stat.h:71
#define SCIP_DECL_DISPOUTPUT(x)
Definition: type_disp.h:126
struct BMS_BlkMem BMS_BLKMEM
Definition: memory.h:419
#define SCIP_ALLOC(x)
Definition: def.h:361
const char * SCIPdispGetName(SCIP_DISP *disp)
Definition: disp.c:283
SCIP callable library.
internal methods for displaying runtime statistics
memory allocation routines