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