Scippy

SCIP

Solving Constraint Integer Programs

stat.c
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the program and library */
4 /* SCIP --- Solving Constraint Integer Programs */
5 /* */
6 /* Copyright (C) 2002-2019 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SCIP is distributed under the terms of the ZIB Academic License. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SCIP; see the file COPYING. If not visit scip.zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file stat.c
17  * @brief methods for problem statistics
18  * @author Tobias Achterberg
19  * @author Stefan Heinz
20  * @author Gregor Hendel
21  * @author Gerald Gamrath
22  * @author Marc Pfetsch
23  * @author Stefan Vigerske
24  */
25 
26 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
27 
28 #include "scip/clock.h"
29 #include "scip/history.h"
30 #include "scip/mem.h"
31 #include "scip/prob.h"
32 #include "scip/pub_message.h"
33 #include "scip/pub_misc.h"
34 #include "scip/pub_var.h"
35 #include "scip/set.h"
36 #include "scip/stat.h"
37 #include "scip/struct_set.h"
38 #include "scip/struct_stat.h"
39 #include "scip/var.h"
40 #include "scip/visual.h"
41 
42 
43 
44 /** creates problem statistics data */
46  SCIP_STAT** stat, /**< pointer to problem statistics data */
47  BMS_BLKMEM* blkmem, /**< block memory */
48  SCIP_SET* set, /**< global SCIP settings */
49  SCIP_PROB* transprob, /**< transformed problem, or NULL */
50  SCIP_PROB* origprob, /**< original problem, or NULL */
51  SCIP_MESSAGEHDLR* messagehdlr /**< message handler */
52  )
53 {
54  assert(stat != NULL);
55  assert(set != NULL);
56 
57  SCIP_ALLOC( BMSallocMemory(stat) );
58 
59  SCIP_CALL( SCIPclockCreate(&(*stat)->solvingtime, SCIP_CLOCKTYPE_DEFAULT) );
60  SCIP_CALL( SCIPclockCreate(&(*stat)->solvingtimeoverall, SCIP_CLOCKTYPE_DEFAULT) );
61  SCIP_CALL( SCIPclockCreate(&(*stat)->presolvingtime, SCIP_CLOCKTYPE_DEFAULT) );
62  SCIP_CALL( SCIPclockCreate(&(*stat)->presolvingtimeoverall, SCIP_CLOCKTYPE_DEFAULT) );
63  SCIP_CALL( SCIPclockCreate(&(*stat)->primallptime, SCIP_CLOCKTYPE_DEFAULT) );
64  SCIP_CALL( SCIPclockCreate(&(*stat)->duallptime, SCIP_CLOCKTYPE_DEFAULT) );
65  SCIP_CALL( SCIPclockCreate(&(*stat)->lexduallptime, SCIP_CLOCKTYPE_DEFAULT) );
66  SCIP_CALL( SCIPclockCreate(&(*stat)->barrierlptime, SCIP_CLOCKTYPE_DEFAULT) );
67  SCIP_CALL( SCIPclockCreate(&(*stat)->resolveinstablelptime, SCIP_CLOCKTYPE_DEFAULT) );
68  SCIP_CALL( SCIPclockCreate(&(*stat)->divinglptime, SCIP_CLOCKTYPE_DEFAULT) );
69  SCIP_CALL( SCIPclockCreate(&(*stat)->strongbranchtime, SCIP_CLOCKTYPE_DEFAULT) );
70  SCIP_CALL( SCIPclockCreate(&(*stat)->conflictlptime, SCIP_CLOCKTYPE_DEFAULT) );
71  SCIP_CALL( SCIPclockCreate(&(*stat)->lpsoltime, SCIP_CLOCKTYPE_DEFAULT) );
72  SCIP_CALL( SCIPclockCreate(&(*stat)->relaxsoltime, SCIP_CLOCKTYPE_DEFAULT) );
73  SCIP_CALL( SCIPclockCreate(&(*stat)->pseudosoltime, SCIP_CLOCKTYPE_DEFAULT) );
74  SCIP_CALL( SCIPclockCreate(&(*stat)->sbsoltime, SCIP_CLOCKTYPE_DEFAULT) );
75  SCIP_CALL( SCIPclockCreate(&(*stat)->nodeactivationtime, SCIP_CLOCKTYPE_DEFAULT) );
76  SCIP_CALL( SCIPclockCreate(&(*stat)->nlpsoltime, SCIP_CLOCKTYPE_DEFAULT) );
77  SCIP_CALL( SCIPclockCreate(&(*stat)->copyclock, SCIP_CLOCKTYPE_DEFAULT) );
78  SCIP_CALL( SCIPclockCreate(&(*stat)->strongpropclock, SCIP_CLOCKTYPE_DEFAULT) );
79  SCIP_CALL( SCIPclockCreate(&(*stat)->reoptupdatetime, SCIP_CLOCKTYPE_DEFAULT) );
80 
81  /* turn statistic timing on or off, depending on the user parameter */
82  SCIPstatEnableOrDisableStatClocks(*stat, set->time_statistictiming);
83 
84  SCIP_CALL( SCIPhistoryCreate(&(*stat)->glbhistory, blkmem) );
85  SCIP_CALL( SCIPhistoryCreate(&(*stat)->glbhistorycrun, blkmem) );
86  SCIP_CALL( SCIPvisualCreate(&(*stat)->visual, messagehdlr) );
87 
88  SCIP_CALL( SCIPregressionCreate(&(*stat)->regressioncandsobjval) );
89 
90  (*stat)->status = SCIP_STATUS_UNKNOWN;
91  (*stat)->marked_nvaridx = 0;
92  (*stat)->marked_ncolidx = 0;
93  (*stat)->marked_nrowidx = 0;
94  (*stat)->userinterrupt = FALSE;
95  (*stat)->userrestart = FALSE;
96  (*stat)->inrestart = FALSE;
97  (*stat)->collectvarhistory = TRUE;
98  (*stat)->performpresol = FALSE;
99  (*stat)->branchedunbdvar = FALSE;
100  (*stat)->disableenforelaxmsg = FALSE;
101  (*stat)->subscipdepth = 0;
102  (*stat)->detertimecnt = 0.0;
103  (*stat)->nreoptruns = 0;
104 
105  SCIPstatReset(*stat, set, transprob, origprob);
106 
107  return SCIP_OKAY;
108 }
109 
110 /** frees problem statistics data */
112  SCIP_STAT** stat, /**< pointer to problem statistics data */
113  BMS_BLKMEM* blkmem /**< block memory */
114  )
115 {
116  assert(stat != NULL);
117  assert(*stat != NULL);
118 
119  SCIPclockFree(&(*stat)->solvingtime);
120  SCIPclockFree(&(*stat)->solvingtimeoverall);
121  SCIPclockFree(&(*stat)->presolvingtime);
122  SCIPclockFree(&(*stat)->presolvingtimeoverall);
123  SCIPclockFree(&(*stat)->primallptime);
124  SCIPclockFree(&(*stat)->duallptime);
125  SCIPclockFree(&(*stat)->lexduallptime);
126  SCIPclockFree(&(*stat)->barrierlptime);
127  SCIPclockFree(&(*stat)->resolveinstablelptime);
128  SCIPclockFree(&(*stat)->divinglptime);
129  SCIPclockFree(&(*stat)->strongbranchtime);
130  SCIPclockFree(&(*stat)->conflictlptime);
131  SCIPclockFree(&(*stat)->lpsoltime);
132  SCIPclockFree(&(*stat)->relaxsoltime);
133  SCIPclockFree(&(*stat)->pseudosoltime);
134  SCIPclockFree(&(*stat)->sbsoltime);
135  SCIPclockFree(&(*stat)->nodeactivationtime);
136  SCIPclockFree(&(*stat)->nlpsoltime);
137  SCIPclockFree(&(*stat)->copyclock);
138  SCIPclockFree(&(*stat)->strongpropclock);
139  SCIPclockFree(&(*stat)->reoptupdatetime);
140 
141  SCIPhistoryFree(&(*stat)->glbhistory, blkmem);
142  SCIPhistoryFree(&(*stat)->glbhistorycrun, blkmem);
143  SCIPvisualFree(&(*stat)->visual);
144 
145  SCIPregressionFree(&(*stat)->regressioncandsobjval);
146 
147  BMSfreeMemory(stat);
148 
149  return SCIP_OKAY;
150 }
151 
152 /** diables the collection of any statistic for a variable */
154  SCIP_STAT* stat /**< problem statistics data */
155  )
156 {
157  assert(stat != NULL);
158 
159  stat->collectvarhistory = FALSE;
160 }
161 
162 /** enables the collection of statistics for a variable */
164  SCIP_STAT* stat /**< problem statistics data */
165  )
166 {
167  assert(stat != NULL);
168 
169  stat->collectvarhistory = TRUE;
170 }
171 
172 /** marks statistics to be able to reset them when solving process is freed */
174  SCIP_STAT* stat /**< problem statistics data */
175  )
176 {
177  assert(stat != NULL);
178 
179  stat->marked_nvaridx = stat->nvaridx;
180  stat->marked_ncolidx = stat->ncolidx;
181  stat->marked_nrowidx = stat->nrowidx;
182 }
183 
184 /** reset statistics to the data before solving started */
186  SCIP_STAT* stat, /**< problem statistics data */
187  SCIP_SET* set, /**< global SCIP settings */
188  SCIP_PROB* transprob, /**< transformed problem, or NULL */
189  SCIP_PROB* origprob /**< original problem, or NULL */
190  )
191 {
192  assert(stat != NULL);
193  assert(stat->marked_nvaridx >= 0);
194  assert(stat->marked_ncolidx >= 0);
195  assert(stat->marked_nrowidx >= 0);
196 
200  SCIPclockReset(stat->duallptime);
207  SCIPclockReset(stat->lpsoltime);
210  SCIPclockReset(stat->sbsoltime);
212  SCIPclockReset(stat->nlpsoltime);
213  SCIPclockReset(stat->copyclock);
215 
217 
219 
220  stat->vsidsweight = 1.0;
221  stat->nlpiterations = 0;
222  stat->nrootlpiterations = 0;
223  stat->nrootfirstlpiterations = 0;
224  stat->nprimallpiterations = 0;
225  stat->nduallpiterations = 0;
226  stat->nlexduallpiterations = 0;
227  stat->nbarrierlpiterations = 0;
228  stat->nprimalresolvelpiterations = 0;
229  stat->ndualresolvelpiterations = 0;
230  stat->nlexdualresolvelpiterations = 0;
231  stat->nnodelpiterations = 0;
232  stat->ninitlpiterations = 0;
233  stat->ndivinglpiterations = 0;
234  stat->nsbdivinglpiterations = 0;
235  stat->nsblpiterations = 0;
236  stat->nsbtimesiterlimhit = 0L;
237  stat->nrootsblpiterations = 0;
238  stat->nconflictlpiterations = 0;
239  stat->nresolveinstablelps = 0;
240  stat->nresolveinstablelpiters = 0;
241  stat->ntotalnodes = 0;
242  stat->ntotalinternalnodes = 0;
243  stat->ntotalnodesmerged = 0;
244  stat->ncreatednodes = 0;
245  stat->nlpsolsfound = 0;
246  stat->nrelaxsolsfound = 0;
247  stat->npssolsfound = 0;
248  stat->nsbsolsfound = 0;
249  stat->nlpbestsolsfound = 0;
250  stat->nrelaxbestsolsfound = 0;
251  stat->npsbestsolsfound = 0;
252  stat->nsbbestsolsfound = 0;
253  stat->nexternalsolsfound = 0;
254  stat->domchgcount = 0;
255  stat->nboundchgs = 0;
256  stat->nholechgs = 0;
257  stat->nprobboundchgs = 0;
258  stat->nprobholechgs = 0;
259  stat->nsbdowndomchgs = 0;
260  stat->nsbupdomchgs = 0;
261  stat->nruns = 0;
262  stat->nconfrestarts = 0;
263  stat->nrootboundchgs = 0;
264  stat->nrootintfixings = 0;
265  stat->prevrunnvars = 0;
266  stat->nvaridx = stat->marked_nvaridx;
267  stat->ncolidx = stat->marked_ncolidx;
268  stat->nrowidx = stat->marked_nrowidx;
269  stat->nnz = 0;
270  stat->avgnnz = 0;
271  stat->lpcount = 0;
272  stat->relaxcount = 0;
273  stat->nlps = 0;
274  stat->nrootlps = 0;
275  stat->nprimallps = 0;
276  stat->nprimalzeroitlps = 0;
277  stat->nduallps = 0;
278  stat->ndualzeroitlps = 0;
279  stat->nlexduallps = 0;
280  stat->nbarrierlps = 0;
281  stat->nbarrierzeroitlps = 0;
282  stat->nprimalresolvelps = 0;
283  stat->ndualresolvelps = 0;
284  stat->nlexdualresolvelps = 0;
285  stat->nnodelps = 0;
286  stat->nisstoppedcalls = 0;
287  stat->ninitlps = 0;
288  stat->ndivinglps = 0;
289  stat->nsbdivinglps = 0;
290  stat->nnumtroublelpmsgs = 0;
291  stat->nstrongbranchs = 0;
292  stat->nrootstrongbranchs = 0;
293  stat->nconflictlps = 0;
294  stat->nnlps = 0;
295  stat->maxtotaldepth = -1;
296  stat->nactiveconss = 0;
297  stat->nenabledconss = 0;
298  stat->solindex = 0;
299  stat->memsavemode = FALSE;
300  stat->nnodesbeforefirst = -1;
301  stat->ninitconssadded = 0;
302  stat->nactiveconssadded = 0;
303  stat->externmemestim = 0;
304  stat->nrunsbeforefirst = -1;
305  stat->firstprimalheur = NULL;
310  stat->primalzeroittime = 0.0;
311  stat->dualzeroittime = 0.0;
312  stat->barrierzeroittime = 0.0;
313  stat->maxcopytime = SCIP_REAL_MIN;
314  stat->mincopytime = SCIP_REAL_MAX;
315  stat->firstlptime = 0.0;
317  stat->ncopies = 0;
318  stat->nclockskipsleft = 0;
319  stat->marked_nvaridx = -1;
320  stat->marked_ncolidx = -1;
321  stat->marked_nrowidx = -1;
322  stat->branchedunbdvar = FALSE;
323  stat->bestefficacy = 0.0;
324  stat->minefficacyfac = 0.5;
325  stat->ncutpoolfails = 0;
326 
327  stat->ndivesetlpiterations = 0;
328  stat->ndivesetcalls = 0;
329  stat->ndivesetlps = 0;
330  stat->totaldivesetdepth = 0;
331 
333  SCIPstatResetPresolving(stat, set, transprob, origprob);
335 }
336 
337 /** reset implication counter */
339  SCIP_STAT* stat /**< problem statistics data */
340  )
341 {
342  assert(stat != NULL);
343 
344  stat->nimplications = 0;
345 }
346 
347 /** reset presolving and current run specific statistics */
349  SCIP_STAT* stat, /**< problem statistics data */
350  SCIP_SET* set, /**< global SCIP settings */
351  SCIP_PROB* transprob, /**< transformed problem, or NULL if not yet existing */
352  SCIP_PROB* origprob /**< original problem, or NULL */
353  )
354 {
355  assert(stat != NULL);
356 
357  stat->npresolrounds = 0;
358  stat->npresolroundsfast = 0;
359  stat->npresolroundsmed = 0;
360  stat->npresolroundsext = 0;
361  stat->npresolfixedvars = 0;
362  stat->npresolaggrvars = 0;
363  stat->npresolchgvartypes = 0;
364  stat->npresolchgbds = 0;
365  stat->npresoladdholes = 0;
366  stat->npresoldelconss = 0;
367  stat->npresoladdconss = 0;
368  stat->npresolupgdconss = 0;
369  stat->npresolchgcoefs = 0;
370  stat->npresolchgsides = 0;
371 
372  SCIPstatResetCurrentRun(stat, set, transprob, origprob, FALSE);
373 }
374 
375 /** reset primal-dual integral */
377  SCIP_STAT* stat, /**< problem statistics data */
378  SCIP_SET* set, /**< global SCIP settings */
379  SCIP_Bool partialreset /**< should time and integral value be kept? (in combination with no statistical
380  * reset, integrals are added for each problem to be solved) */
381  )
382 {
383  assert(stat != NULL);
384 
385  stat->previousgap = 100.0;
387  stat->lastdualbound = SCIP_UNKNOWN;
388  stat->lastlowerbound = -SCIPsetInfinity(set);
389  stat->lastupperbound = SCIPsetInfinity(set);
390 
391  /* partial resets keep the integral value and previous evaluation time */
392  if( !partialreset )
393  {
394  stat->previntegralevaltime = 0.0;
395  stat->primaldualintegral = 0.0;
396  }
397 }
398 
399 /** update the primal-dual integral statistic. method accepts + and - SCIPsetInfinity() as values for
400  * upper and lower bound, respectively
401  */
403  SCIP_STAT* stat, /**< problem statistics data */
404  SCIP_SET* set, /**< global SCIP settings */
405  SCIP_PROB* transprob, /**< transformed problem */
406  SCIP_PROB* origprob, /**< original problem */
407  SCIP_Real upperbound, /**< current upper bound in transformed problem, or infinity */
408  SCIP_Real lowerbound /**< current lower bound in transformed space, or -infinity */
409  )
410 {
411  SCIP_Real currentgap;
412  SCIP_Real solvingtime;
413  SCIP_Real primalbound;
414  SCIP_Real dualbound;
415 
416  assert(stat != NULL);
417  assert(set != NULL);
418 
419  solvingtime = SCIPclockGetTime(stat->solvingtime);
420  assert(solvingtime >= stat->previntegralevaltime);
421 
422  if( !SCIPsetIsInfinity(set, upperbound) ) /*lint !e777*/
423  {
424  /* get value in original space for gap calculation */
425  primalbound = SCIPprobExternObjval(transprob, origprob, set, upperbound);
426 
427  if( SCIPsetIsZero(set, primalbound) )
428  primalbound = 0.0;
429  }
430  else
431  {
432  /* no new upper bound: use stored values from last update */
433  upperbound = stat->lastupperbound;
434  primalbound = stat->lastprimalbound;
435  assert(SCIPsetIsZero(set, primalbound) == (primalbound == 0.0)); /*lint !e777*/
436  }
437 
438  if( !SCIPsetIsInfinity(set, -lowerbound) ) /*lint !e777*/
439  {
440  /* get value in original space for gap calculation */
441  dualbound = SCIPprobExternObjval(transprob, origprob, set, lowerbound);
442 
443  if( SCIPsetIsZero(set, dualbound) )
444  dualbound = 0.0;
445  }
446  else
447  {
448  /* no new lower bound: use stored values from last update */
449  lowerbound = stat->lastlowerbound;
450  dualbound = stat->lastdualbound;
451  assert(SCIPsetIsZero(set, dualbound) == (dualbound == 0.0)); /*lint !e777*/
452  }
453 
454  /* computation of the gap, special cases are handled first */
455  if( primalbound == SCIP_UNKNOWN || dualbound == SCIP_UNKNOWN ) /*lint !e777*/
456  currentgap = 100.0;
457  /* the gap is 0.0 if bounds coincide */
458  else if( SCIPsetIsGE(set, lowerbound, upperbound) || SCIPsetIsEQ(set, primalbound, dualbound) )
459  currentgap = 0.0;
460  /* the gap is 100.0 if bounds have different signs */
461  else if( primalbound * dualbound <= 0.0 ) /*lint !e777*/
462  currentgap = 100.0;
463  else if( !SCIPsetIsInfinity(set, REALABS(primalbound)) && !SCIPsetIsInfinity(set, REALABS(dualbound)) )
464  {
465  SCIP_Real absprim = REALABS(primalbound);
466  SCIP_Real absdual = REALABS(dualbound);
467 
468  /* The gap in the definition of the primal-dual integral differs from the default SCIP gap function.
469  * Here, the MAX(primalbound, dualbound) is taken for gap quotient in order to ensure a gap <= 100.
470  */
471  currentgap = 100.0 * REALABS(primalbound - dualbound) / MAX(absprim, absdual);
472  assert(SCIPsetIsLE(set, currentgap, 100.0));
473  }
474  else
475  currentgap = 100.0;
476 
477  /* if primal and dual bound have opposite signs, the gap always evaluates to 100.0% */
478  assert(currentgap == 0.0 || currentgap == 100.0 || SCIPsetIsGE(set, primalbound * dualbound, 0.0));
479 
480  /* update the integral based on previous information */
481  stat->primaldualintegral += (solvingtime - stat->previntegralevaltime) * stat->previousgap;
482 
483  /* update all relevant information for next evaluation */
484  stat->previousgap = currentgap;
485  stat->previntegralevaltime = solvingtime;
486  stat->lastprimalbound = primalbound;
487  stat->lastdualbound = dualbound;
488  stat->lastlowerbound = lowerbound;
489  stat->lastupperbound = upperbound;
490 }
491 
492 /** update and return the primal-dual integral statistic */
494  SCIP_STAT* stat, /**< problem statistics data */
495  SCIP_SET* set, /**< global SCIP settings */
496  SCIP_PROB* transprob, /**< transformed problem */
497  SCIP_PROB* origprob /**< original problem */
498  )
499 {
500  assert(stat != NULL);
501  assert(set != NULL);
502  assert(transprob != NULL);
503  assert(origprob != NULL);
504 
505  /* update the primal dual integral first */
506  SCIPstatUpdatePrimalDualIntegral(stat, set, transprob, origprob, SCIPsetInfinity(set), -SCIPsetInfinity(set));
507 
508  return stat->primaldualintegral;
509 }
510 
511 /** reset current branch and bound run specific statistics */
513  SCIP_STAT* stat, /**< problem statistics data */
514  SCIP_SET* set, /**< global SCIP settings */
515  SCIP_PROB* transprob, /**< transformed problem, or NULL */
516  SCIP_PROB* origprob, /**< original problem, or NULL */
517  SCIP_Bool solved /**< is problem already solved? */
518  )
519 {
520  assert(stat != NULL);
521 
522  stat->nnodes = 0;
523  stat->ninternalnodes = 0;
524  stat->ncreatednodesrun = 0;
525  stat->nactivatednodes = 0;
526  stat->ndeactivatednodes = 0;
527  stat->nbacktracks = 0;
528  stat->ndelayedcutoffs = 0;
529  stat->nreprops = 0;
530  stat->nrepropboundchgs = 0;
531  stat->nrepropcutoffs = 0;
532  stat->lastdivenode = 0;
533  stat->lastconflictnode = 0;
534  stat->bestsolnode = 0;
538  stat->lastbranchvar = NULL;
540  stat->nrootboundchgsrun = 0;
541  stat->nrootintfixingsrun = 0;
542  stat->npricerounds = 0;
543  stat->nseparounds = 0;
544  stat->maxdepth = -1;
545  stat->plungedepth = 0;
546  stat->nobjleaves = 0;
547  stat->ninfeasleaves = 0;
548  stat->nfeasleaves = 0;
549  stat->branchedunbdvar = FALSE;
550  stat->nnumtroublelpmsgs = 0;
551 
552  stat->nearlybacktracks = 0;
553  stat->nnodesaboverefbound = 0;
554 
555  assert(transprob == NULL || origprob != NULL);
556  /* calculate the reference bound in transformed space from the reference value */
557  if( transprob != NULL && !SCIPsetIsInfinity(set, SCIPsetGetReferencevalue(set)) )
558  stat->referencebound = SCIPprobInternObjval(transprob, origprob, set, SCIPsetGetReferencevalue(set));
559  else
560  stat->referencebound = SCIPsetInfinity(set);
561 
562  if( !solved )
563  stat->status = SCIP_STATUS_UNKNOWN;
564 
566 
568 
569  SCIPstatResetDisplay(stat);
570 }
571 
572 /** resets display statistics, such that a new header line is displayed before the next display line */
574  SCIP_STAT* stat /**< problem statistics data */
575  )
576 {
577  assert(stat != NULL);
578 
579  stat->lastdispnode = 0;
580  stat->ndisplines = 0;
581 }
582 
583 /** increases LP count, such that all lazy updates depending on the LP are enforced again */
585  SCIP_STAT* stat /**< problem statistics data */
586  )
587 {
588  assert(stat != NULL);
589 
590  stat->lpcount++;
591 }
592 
593 /** depending on the current memory usage, switches mode flag to standard or memory saving mode */
595  SCIP_STAT* stat, /**< problem statistics data */
596  SCIP_SET* set, /**< global SCIP settings */
597  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
598  SCIP_MEM* mem /**< block memory pools */
599  )
600 {
601  assert(stat != NULL);
602  assert(set != NULL);
603 
604  if( SCIPsetIsLT(set, set->mem_savefac, 1.0) )
605  {
606  SCIP_Longint memused;
607 
608  memused = SCIPmemGetTotal(mem);
609  if( !stat->memsavemode && memused >= set->mem_savefac * set->limit_memory * 1024.0 * 1024.0 )
610  {
611  /* switch to memory saving mode */
612  SCIPmessagePrintVerbInfo(messagehdlr, set->disp_verblevel, SCIP_VERBLEVEL_HIGH,
613  "(node %" SCIP_LONGINT_FORMAT ") switching to memory saving mode (mem: %.1fM/%.1fM)\n",
614  stat->nnodes, (SCIP_Real)memused/(1024.0*1024.0), set->limit_memory);
615  stat->memsavemode = TRUE;
616  set->nodesel = NULL;
617  }
618  else if( stat->memsavemode && memused < 0.5 * set->mem_savefac * set->limit_memory * 1024.0 * 1024.0 )
619  {
620  /* switch to standard mode */
621  SCIPmessagePrintVerbInfo(messagehdlr, set->disp_verblevel, SCIP_VERBLEVEL_HIGH,
622  "(node %" SCIP_LONGINT_FORMAT ") switching to standard mode (mem: %.1fM/%.1fM)\n",
623  stat->nnodes, (SCIP_Real)memused/(1024.0*1024.0), set->limit_memory);
624  stat->memsavemode = FALSE;
625  set->nodesel = NULL;
626  }
627  }
628  else
629  stat->memsavemode = FALSE;
630 }
631 
632 /** returns the estimated number of bytes used by extern software, e.g., the LP solver */
634  SCIP_STAT* stat /**< dynamic SCIP statistics */
635  )
636 {
637  return stat->externmemestim;
638 }
639 
640 /** enables or disables all statistic clocks of \p stat concerning LP execution time, strong branching time, etc.
641  *
642  * @note: The (pre-)solving time clocks which are relevant for the output during (pre-)solving
643  * are not affected by this method
644  *
645  * @see: For completely disabling all timing of SCIP, consider setting the parameter timing/enabled to FALSE
646  */
648  SCIP_STAT* stat, /**< SCIP statistics */
649  SCIP_Bool enable /**< should the LP clocks be enabled? */
650  )
651 {
652  assert(stat != NULL);
653 
654  SCIPclockEnableOrDisable(stat->primallptime, enable);
655  SCIPclockEnableOrDisable(stat->duallptime, enable);
659  SCIPclockEnableOrDisable(stat->divinglptime, enable);
662  SCIPclockEnableOrDisable(stat->lpsoltime, enable);
663  SCIPclockEnableOrDisable(stat->relaxsoltime, enable);
665  SCIPclockEnableOrDisable(stat->sbsoltime, enable);
667  SCIPclockEnableOrDisable(stat->nlpsoltime, enable);
668  SCIPclockEnableOrDisable(stat->copyclock, enable);
670 }
671 
672 /** recompute root LP best-estimate from scratch */
674  SCIP_STAT* stat, /**< SCIP statistics */
675  SCIP_SET* set, /**< global SCIP settings */
676  SCIP_Real rootlpobjval, /**< root LP objective value */
677  SCIP_VAR** vars, /**< problem variables */
678  int nvars /**< number of variables */
679  )
680 {
681  int v;
682  stat->rootlpbestestimate = rootlpobjval;
683 
684  /* compute best-estimate contribution for every variable */
685  for( v = 0; v < nvars; ++v )
686  {
687  SCIP_Real rootlpsol;
688  SCIP_Real varminpseudoscore;
689 
690  /* stop at the first continuous variable */
691  if( !SCIPvarIsIntegral(vars[v]) )
692  break;
693 
694  rootlpsol = SCIPvarGetRootSol(vars[v]);
695  varminpseudoscore = SCIPvarGetMinPseudocostScore(vars[v], stat, set, rootlpsol);
696  assert(varminpseudoscore >= 0);
697  stat->rootlpbestestimate += varminpseudoscore;
698 
699  SCIPstatDebugMsg(stat, "Root LP Estimate initialization: <%s> + %15.9f\n", SCIPvarGetName(vars[v]), varminpseudoscore);
700  }
701 }
702 
703 /** update root LP best-estimate with changed variable pseudo-costs */
705  SCIP_STAT* stat, /**< SCIP statistics */
706  SCIP_SET* set, /**< global SCIP settings */
707  SCIP_VAR* var, /**< variable with changed pseudo costs */
708  SCIP_Real oldrootpscostscore /**< old minimum pseudo cost score of variable */
709  )
710 {
711  SCIP_Real rootlpsol;
712  SCIP_Real varminpseudoscore;
713 
715 
716  /* entire root LP best-estimate must be computed from scratch first */
717  if( stat->rootlpbestestimate == SCIP_INVALID ) /*lint !e777*/
718  return SCIP_OKAY;
719 
720  rootlpsol = SCIPvarGetRootSol(var);
721 
722  /* LP root estimate only works for variables with fractional LP root solution */
723  if( SCIPsetIsFeasIntegral(set, rootlpsol) )
724  return SCIP_OKAY;
725 
726  /* subtract old pseudo cost contribution and add new contribution afterwards */
727  stat->rootlpbestestimate -= oldrootpscostscore;
728 
729  varminpseudoscore = SCIPvarGetMinPseudocostScore(var, stat, set, rootlpsol);
730  assert(varminpseudoscore >= 0.0);
731  stat->rootlpbestestimate += varminpseudoscore;
732 
733  SCIPstatDebugMsg(stat, "Root LP estimate update: <%s> - %15.9f + %15.9f\n", SCIPvarGetName(var), oldrootpscostscore, varminpseudoscore);
734 
735  return SCIP_OKAY;
736 }
737 
738 /** prints a debug message */
740  SCIP_STAT* stat, /**< SCIP statistics */
741  const char* sourcefile, /**< name of the source file that called the function */
742  int sourceline, /**< line in the source file where the function was called */
743  const char* formatstr, /**< format string like in printf() function */
744  ... /**< format arguments line in printf() function */
745  )
746 {
747  va_list ap;
748 
749  assert( sourcefile != NULL );
750  assert( stat != NULL );
751 
752  if ( stat->subscipdepth > 0 )
753  printf("%d: [%s:%d] debug: ", stat->subscipdepth, sourcefile, sourceline);
754  else
755  printf("[%s:%d] debug: ", sourcefile, sourceline);
756 
757  va_start(ap, formatstr); /*lint !e838*/
758  printf(formatstr, ap);
759  va_end(ap);
760 }
761 
762 /** prints a debug message without precode */
764  SCIP_STAT* stat, /**< SCIP statistics */
765  const char* formatstr, /**< format string like in printf() function */
766  ... /**< format arguments line in printf() function */
767  )
768 { /*lint --e{715}*/
769  va_list ap;
770 
771  va_start(ap, formatstr); /*lint !e838*/
772  printf(formatstr, ap);
773  va_end(ap);
774 }
SCIP_Longint nlexduallps
Definition: struct_stat.h:182
SCIP_Longint nprimallps
Definition: struct_stat.h:178
SCIP_RETCODE SCIPvisualCreate(SCIP_VISUAL **visual, SCIP_MESSAGEHDLR *messagehdlr)
Definition: visual.c:75
SCIP_Longint ndualresolvelpiterations
Definition: struct_stat.h:61
SCIP_Real lastupperbound
Definition: struct_stat.h:138
SCIP_Longint nsbdivinglps
Definition: struct_stat.h:192
int npresoladdconss
Definition: struct_stat.h:235
SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)
Definition: set.c:5953
SCIP_Longint ninfeasleaves
Definition: struct_stat.h:77
SCIP_Real firstlpdualbound
Definition: struct_stat.h:118
int npresolroundsfast
Definition: struct_stat.h:226
#define NULL
Definition: def.h:253
SCIP_Longint nnodelpiterations
Definition: struct_stat.h:63
int marked_ncolidx
Definition: struct_stat.h:214
SCIP_Bool SCIPsetIsLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6011
void SCIPstatEnableVarHistory(SCIP_STAT *stat)
Definition: stat.c:163
SCIP_Longint nlpsolsfound
Definition: struct_stat.h:92
void SCIPstatPrintDebugMessage(SCIP_STAT *stat, const char *sourcefile, int sourceline, const char *formatstr,...)
Definition: stat.c:739
int solindex
Definition: struct_stat.h:253
SCIP_Longint nsbdowndomchgs
Definition: struct_stat.h:110
SCIP_STATUS status
Definition: struct_stat.h:170
SCIP_Longint nlpiterations
Definition: struct_stat.h:53
void SCIPstatComputeRootLPBestEstimate(SCIP_STAT *stat, SCIP_SET *set, SCIP_Real rootlpobjval, SCIP_VAR **vars, int nvars)
Definition: stat.c:673
SCIP_Longint externmemestim
Definition: struct_stat.h:116
SCIP_Longint nfeasleaves
Definition: struct_stat.h:76
SCIP_Longint nnumtroublelpmsgs
Definition: struct_stat.h:193
SCIP_Longint ndeactivatednodes
Definition: struct_stat.h:84
SCIP_Longint nlexdualresolvelps
Definition: struct_stat.h:187
int npricerounds
Definition: struct_stat.h:216
SCIP_Longint relaxcount
Definition: struct_stat.h:175
#define SCIPstatDebugMsg
Definition: stat.h:294
SCIP_Longint nlps
Definition: struct_stat.h:176
SCIP_Longint nbarrierlpiterations
Definition: struct_stat.h:59
SCIP_Longint ninitconssadded
Definition: struct_stat.h:114
SCIP_CLOCK * conflictlptime
Definition: struct_stat.h:155
int nrunsbeforefirst
Definition: struct_stat.h:254
SCIP_Real rootlowerbound
Definition: struct_stat.h:119
internal methods for clocks and timing issues
void SCIPstatUpdateMemsaveMode(SCIP_STAT *stat, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_MEM *mem)
Definition: stat.c:594
SCIP_Longint ntotalnodes
Definition: struct_stat.h:78
SCIP_Real previntegralevaltime
Definition: struct_stat.h:134
int npresolaggrvars
Definition: struct_stat.h:230
SCIP_Real lastbranchvalue
Definition: struct_stat.h:131
SCIP_Longint nrootfirstlpiterations
Definition: struct_stat.h:55
SCIP_Longint ndivinglps
Definition: struct_stat.h:190
SCIP_Longint nsbtimesiterlimhit
Definition: struct_stat.h:112
SCIP_RETCODE SCIPregressionCreate(SCIP_REGRESSION **regression)
Definition: misc.c:404
SCIP_BRANCHDIR lastbranchdir
Definition: struct_stat.h:171
int npresolfixedvars
Definition: struct_stat.h:229
void SCIPstatDisableVarHistory(SCIP_STAT *stat)
Definition: stat.c:153
SCIP_Real lastsolgap
Definition: struct_stat.h:124
SCIP_Longint nrootstrongbranchs
Definition: struct_stat.h:195
SCIP_Real SCIPsetInfinity(SCIP_SET *set)
Definition: set.c:5813
SCIP_Longint nactiveconssadded
Definition: struct_stat.h:115
int nclockskipsleft
Definition: struct_stat.h:258
int npresoldelconss
Definition: struct_stat.h:234
SCIP_Longint nstrongbranchs
Definition: struct_stat.h:194
SCIP_Longint nholechgs
Definition: struct_stat.h:107
SCIP_RETCODE SCIPhistoryCreate(SCIP_HISTORY **history, BMS_BLKMEM *blkmem)
Definition: history.c:41
SCIP_Longint nrootsblpiterations
Definition: struct_stat.h:69
void SCIPvisualFree(SCIP_VISUAL **visual)
Definition: visual.c:96
#define FALSE
Definition: def.h:73
void SCIPstatEnableOrDisableStatClocks(SCIP_STAT *stat, SCIP_Bool enable)
Definition: stat.c:647
SCIP_Bool SCIPsetIsFeasIntegral(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6494
SCIP_Longint nrootlps
Definition: struct_stat.h:177
SCIP_Longint ncreatednodes
Definition: struct_stat.h:81
void SCIPhistoryReset(SCIP_HISTORY *history)
Definition: history.c:68
SCIP_Real primaldualintegral
Definition: struct_stat.h:132
SCIP_Bool SCIPsetIsZero(SCIP_SET *set, SCIP_Real val)
Definition: set.c:6065
#define TRUE
Definition: def.h:72
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
int nenabledconss
Definition: struct_stat.h:223
SCIP_Longint nnlps
Definition: struct_stat.h:197
void SCIPstatResetImplications(SCIP_STAT *stat)
Definition: stat.c:338
SCIP_Real SCIPprobInternObjval(SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_SET *set, SCIP_Real objval)
Definition: prob.c:2096
SCIP_Longint nbacktracks
Definition: struct_stat.h:87
public methods for problem variables
int maxtotaldepth
Definition: struct_stat.h:220
SCIP_CLOCK * barrierlptime
Definition: struct_stat.h:151
int ndisplines
Definition: struct_stat.h:218
SCIP_EXPORT SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
Definition: var.c:16857
SCIP_Longint lastdispnode
Definition: struct_stat.h:101
SCIP_Longint nnodesaboverefbound
Definition: struct_stat.h:86
int npresolroundsext
Definition: struct_stat.h:228
methods for creating output for visualization tools (VBC, BAK)
void SCIPclockEnableOrDisable(SCIP_CLOCK *clck, SCIP_Bool enable)
Definition: clock.c:250
SCIP_CLOCK * copyclock
Definition: struct_stat.h:162
SCIP_Real rootlpbestestimate
Definition: struct_stat.h:139
#define BMSfreeMemory(ptr)
Definition: memory.h:135
int maxdepth
Definition: struct_stat.h:219
SCIP_CLOCK * nlpsoltime
Definition: struct_stat.h:161
SCIP_Real lastdualbound
Definition: struct_stat.h:136
SCIP_Longint nlpbestsolsfound
Definition: struct_stat.h:96
SCIP_Real dualzeroittime
Definition: struct_stat.h:126
SCIP_Longint nexternalsolsfound
Definition: struct_stat.h:100
void SCIPstatEnforceLPUpdates(SCIP_STAT *stat)
Definition: stat.c:584
internal methods for branching and inference history
int nrootintfixings
Definition: struct_stat.h:207
SCIP_Longint ntotalnodesmerged
Definition: struct_stat.h:80
SCIP_Longint nsblpiterations
Definition: struct_stat.h:68
SCIP_Real primalzeroittime
Definition: struct_stat.h:125
int nrootboundchgs
Definition: struct_stat.h:205
SCIP_Bool SCIPsetIsGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:6047
SCIP_HISTORY * glbhistorycrun
Definition: struct_stat.h:166
SCIP_EXPORT SCIP_Real SCIPvarGetRootSol(SCIP_VAR *var)
Definition: var.c:12842
int ncutpoolfails
Definition: struct_stat.h:203
SCIP_Real avgnnz
Definition: struct_stat.h:117
int nconfrestarts
Definition: struct_stat.h:204
SCIP_Longint nlexduallpiterations
Definition: struct_stat.h:58
SCIP_Bool SCIPsetIsLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:5993
SCIP_CLOCK * strongpropclock
Definition: struct_stat.h:163
int npresolchgcoefs
Definition: struct_stat.h:237
int npresolchgvartypes
Definition: struct_stat.h:231
SCIP_RETCODE SCIPstatUpdateVarRootLPBestEstimate(SCIP_STAT *stat, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldrootpscostscore)
Definition: stat.c:704
SCIP_Real barrierzeroittime
Definition: struct_stat.h:127
SCIP_Longint nobjleaves
Definition: struct_stat.h:75
SCIP_Longint npssolsfound
Definition: struct_stat.h:94
void SCIPregressionReset(SCIP_REGRESSION *regression)
Definition: misc.c:388
SCIP_EXPORT const char * SCIPvarGetName(SCIP_VAR *var)
Definition: var.c:16738
SCIP_Real mincopytime
Definition: struct_stat.h:129
int npresolroundsmed
Definition: struct_stat.h:227
int prevrunnvars
Definition: struct_stat.h:209
SCIP_EXPORT SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)
Definition: var.c:16929
internal methods for storing and manipulating the main problem
void SCIPmessagePrintVerbInfo(SCIP_MESSAGEHDLR *messagehdlr, SCIP_VERBLEVEL verblevel, SCIP_VERBLEVEL msgverblevel, const char *formatstr,...)
Definition: message.c:668
void SCIPstatResetCurrentRun(SCIP_STAT *stat, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_Bool solved)
Definition: stat.c:512
SCIP_Longint lpcount
Definition: struct_stat.h:174
SCIP_RETCODE SCIPstatFree(SCIP_STAT **stat, BMS_BLKMEM *blkmem)
Definition: stat.c:111
int ndivesetcalls
Definition: struct_stat.h:201
methods for block memory pools and memory buffers
SCIP_Longint bestsolnode
Definition: struct_stat.h:104
void SCIPclockReset(SCIP_CLOCK *clck)
Definition: clock.c:199
SCIP_Longint nconflictlpiterations
Definition: struct_stat.h:70
int npresolchgsides
Definition: struct_stat.h:238
SCIP_CLOCK * pseudosoltime
Definition: struct_stat.h:158
void SCIPstatReset(SCIP_STAT *stat, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob)
Definition: stat.c:185
SCIP_Longint nrelaxbestsolsfound
Definition: struct_stat.h:97
SCIP_Longint nsbupdomchgs
Definition: struct_stat.h:111
SCIP_HEUR * firstprimalheur
Definition: struct_stat.h:169
SCIP_Longint ninitlpiterations
Definition: struct_stat.h:64
SCIP_LPSOLSTAT lastsblpsolstats[2]
Definition: struct_stat.h:172
SCIP_Real SCIPclockGetTime(SCIP_CLOCK *clck)
Definition: clock.c:428
SCIP_Longint nsbdivinglpiterations
Definition: struct_stat.h:67
SCIP_REGRESSION * regressioncandsobjval
Definition: struct_stat.h:52
SCIP_Longint nprimalresolvelpiterations
Definition: struct_stat.h:60
int nseparounds
Definition: struct_stat.h:217
SCIP_HISTORY * glbhistory
Definition: struct_stat.h:165
#define REALABS(x)
Definition: def.h:188
SCIP_Longint nconflictlps
Definition: struct_stat.h:196
int npresolchgbds
Definition: struct_stat.h:232
internal methods for global SCIP settings
#define SCIP_CALL(x)
Definition: def.h:365
int npresoladdholes
Definition: struct_stat.h:233
int marked_nvaridx
Definition: struct_stat.h:213
SCIP_Longint nsbbestsolsfound
Definition: struct_stat.h:99
SCIP_Longint nduallpiterations
Definition: struct_stat.h:57
SCIP_Longint nbarrierzeroitlps
Definition: struct_stat.h:184
SCIP_Real SCIPvarGetMinPseudocostScore(SCIP_VAR *var, SCIP_STAT *stat, SCIP_SET *set, SCIP_Real solval)
Definition: var.c:14149
SCIP_Bool SCIPsetIsEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
Definition: set.c:5975
SCIP_Real vsidsweight
Definition: struct_stat.h:120
void SCIPstatResetPrimalDualIntegral(SCIP_STAT *stat, SCIP_SET *set, SCIP_Bool partialreset)
Definition: stat.c:376
void SCIPstatResetDisplay(SCIP_STAT *stat)
Definition: stat.c:573
SCIP_Longint ncreatednodesrun
Definition: struct_stat.h:82
SCIP_Longint nprimalresolvelps
Definition: struct_stat.h:185
SCIP_Longint nresolveinstablelps
Definition: struct_stat.h:71
SCIP_CLOCK * divinglptime
Definition: struct_stat.h:153
SCIP_Longint nprobboundchgs
Definition: struct_stat.h:108
SCIP_RETCODE SCIPclockCreate(SCIP_CLOCK **clck, SCIP_CLOCKTYPE clocktype)
Definition: clock.c:160
SCIP_Longint nduallps
Definition: struct_stat.h:180
internal methods for problem variables
#define SCIP_UNKNOWN
Definition: def.h:185
SCIP_Real bestefficacy
Definition: struct_stat.h:141
SCIP_Longint nisstoppedcalls
Definition: struct_stat.h:198
public data structures and miscellaneous methods
#define SCIP_Bool
Definition: def.h:70
SCIP_Real lastprimalbound
Definition: struct_stat.h:135
SCIP_Longint ndivesetlpiterations
Definition: struct_stat.h:66
SCIP_Longint ndualresolvelps
Definition: struct_stat.h:186
SCIP_CLOCK * sbsoltime
Definition: struct_stat.h:159
SCIP_Longint ndivesetlps
Definition: struct_stat.h:191
SCIP_Real minefficacyfac
Definition: struct_stat.h:142
SCIP_CLOCK * presolvingtime
Definition: struct_stat.h:146
SCIP_Bool memsavemode
Definition: struct_stat.h:259
int npresolrounds
Definition: struct_stat.h:225
SCIP_Longint nearlybacktracks
Definition: struct_stat.h:85
SCIP_Longint nlexdualresolvelpiterations
Definition: struct_stat.h:62
SCIP_Bool branchedunbdvar
Definition: struct_stat.h:265
SCIP_Real lastlowerbound
Definition: struct_stat.h:137
SCIP_RETCODE SCIPstatCreate(SCIP_STAT **stat, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_MESSAGEHDLR *messagehdlr)
Definition: stat.c:45
void SCIPclockFree(SCIP_CLOCK **clck)
Definition: clock.c:175
int marked_nrowidx
Definition: struct_stat.h:215
SCIP_Longint nrepropcutoffs
Definition: struct_stat.h:91
SCIP_Longint lastdivenode
Definition: struct_stat.h:102
SCIP_Longint nresolveinstablelpiters
Definition: struct_stat.h:72
SCIP_Real maxcopytime
Definition: struct_stat.h:128
SCIP_CLOCK * resolveinstablelptime
Definition: struct_stat.h:152
datastructures for problem statistics
SCIP_CLOCK * relaxsoltime
Definition: struct_stat.h:157
SCIP_Real SCIPsetGetReferencevalue(SCIP_SET *set)
Definition: set.c:5695
SCIP_Longint nnz
Definition: struct_stat.h:173
void SCIPregressionFree(SCIP_REGRESSION **regression)
Definition: misc.c:420
SCIP_Real SCIPstatGetPrimalDualIntegral(SCIP_STAT *stat, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob)
Definition: stat.c:493
SCIP_CLOCK * lexduallptime
Definition: struct_stat.h:150
SCIP_Longint nnodesbeforefirst
Definition: struct_stat.h:113
#define SCIP_REAL_MAX
Definition: def.h:165
SCIP_Longint nrootlpiterations
Definition: struct_stat.h:54
SCIP_CLOCK * strongbranchtime
Definition: struct_stat.h:154
#define SCIP_REAL_MIN
Definition: def.h:166
#define SCIP_LONGINT_FORMAT
Definition: def.h:156
SCIP_Real firstsolgap
Definition: struct_stat.h:123
#define MAX(x, y)
Definition: def.h:222
#define SCIP_DEFAULT_INFINITY
Definition: def.h:169
int nactiveconss
Definition: struct_stat.h:222
void SCIPstatResetPresolving(SCIP_STAT *stat, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob)
Definition: stat.c:348
SCIP_Longint lastconflictnode
Definition: struct_stat.h:103
SCIP_Longint domchgcount
Definition: struct_stat.h:105
SCIP_Longint SCIPmemGetTotal(SCIP_MEM *mem)
Definition: mem.c:98
SCIP_CLOCK * solvingtime
Definition: struct_stat.h:144
SCIP_Longint nbarrierlps
Definition: struct_stat.h:183
SCIP_Longint nprimalzeroitlps
Definition: struct_stat.h:179
SCIP_CLOCK * primallptime
Definition: struct_stat.h:148
SCIP_Longint npsbestsolsfound
Definition: struct_stat.h:98
public methods for message output
int nrootboundchgsrun
Definition: struct_stat.h:206
SCIP_Longint nboundchgs
Definition: struct_stat.h:106
#define SCIP_Real
Definition: def.h:164
internal methods for problem statistics
void SCIPstatUpdatePrimalDualIntegral(SCIP_STAT *stat, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_Real upperbound, SCIP_Real lowerbound)
Definition: stat.c:402
SCIP_Real firstprimaltime
Definition: struct_stat.h:122
SCIP_Real referencebound
Definition: struct_stat.h:140
SCIP_Longint SCIPstatGetMemExternEstim(SCIP_STAT *stat)
Definition: stat.c:633
SCIP_Longint nrepropboundchgs
Definition: struct_stat.h:90
SCIP_Real firstprimalbound
Definition: struct_stat.h:121
SCIP_Longint ntotalinternalnodes
Definition: struct_stat.h:79
#define BMSallocMemory(ptr)
Definition: memory.h:109
#define SCIP_INVALID
Definition: def.h:184
SCIP_CLOCK * duallptime
Definition: struct_stat.h:149
#define SCIP_Longint
Definition: def.h:149
SCIP_Longint nactivatednodes
Definition: struct_stat.h:83
SCIP_VAR * lastbranchvar
Definition: struct_stat.h:167
SCIP_Longint nprimallpiterations
Definition: struct_stat.h:56
SCIP_Longint nreprops
Definition: struct_stat.h:89
SCIP_Longint nsbsolsfound
Definition: struct_stat.h:95
SCIP_CLOCK * nodeactivationtime
Definition: struct_stat.h:160
SCIP_Longint ndualzeroitlps
Definition: struct_stat.h:181
SCIP_Real firstlptime
Definition: struct_stat.h:130
SCIP_Bool collectvarhistory
Definition: struct_stat.h:263
SCIP_Longint ninternalnodes
Definition: struct_stat.h:74
SCIP_Real SCIPprobExternObjval(SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_SET *set, SCIP_Real objval)
Definition: prob.c:2074
int plungedepth
Definition: struct_stat.h:221
SCIP_Real previousgap
Definition: struct_stat.h:133
SCIP_Longint nnodelps
Definition: struct_stat.h:188
SCIP_Longint nnodes
Definition: struct_stat.h:73
int nrootintfixingsrun
Definition: struct_stat.h:208
struct BMS_BlkMem BMS_BLKMEM
Definition: memory.h:427
SCIP_Longint nrelaxsolsfound
Definition: struct_stat.h:93
#define SCIP_ALLOC(x)
Definition: def.h:376
SCIP_Longint nprobholechgs
Definition: struct_stat.h:109
void SCIPhistoryFree(SCIP_HISTORY **history, BMS_BLKMEM *blkmem)
Definition: history.c:56
int npresolupgdconss
Definition: struct_stat.h:236
void SCIPstatMark(SCIP_STAT *stat)
Definition: stat.c:173
datastructures for global SCIP settings
int subscipdepth
Definition: struct_stat.h:200
void SCIPstatDebugMessagePrint(SCIP_STAT *stat, const char *formatstr,...)
Definition: stat.c:763
SCIP_Longint ninitlps
Definition: struct_stat.h:189
SCIP_Longint ndelayedcutoffs
Definition: struct_stat.h:88
SCIP_CLOCK * lpsoltime
Definition: struct_stat.h:156
int nimplications
Definition: struct_stat.h:224
SCIP_Longint totaldivesetdepth
Definition: struct_stat.h:199
SCIP_Longint ndivinglpiterations
Definition: struct_stat.h:65