/** initializes presolver */
SCIP_RETCODE SCIPpresolInit(
SCIP_PRESOL* presol, /**< presolver */
SCIP_SET* set /**< global SCIP settings */
)
{
assert(presol != NULL);
assert(set != NULL);
if( presol->initialized )
{
SCIPerrorMessage("presolver <%s> already initialized\n", presol->name);
return SCIP_INVALIDCALL;
}
if( set->misc_resetstat )
{
SCIPclockReset(presol->setuptime);
SCIPclockReset(presol->presolclock);
presol->lastnfixedvars = 0;
presol->lastnaggrvars = 0;
presol->lastnchgvartypes = 0;
presol->lastnchgbds = 0;
presol->lastnaddholes = 0;
presol->lastndelconss = 0;
presol->lastnaddconss = 0;
presol->lastnupgdconss = 0;
presol->lastnchgcoefs = 0;
presol->lastnchgsides = 0;
presol->nfixedvars = 0;
presol->naggrvars = 0;
presol->nchgvartypes = 0;
presol->nchgbds = 0;
presol->naddholes = 0;
presol->ndelconss = 0;
presol->naddconss = 0;
presol->nupgdconss = 0;
presol->nchgcoefs = 0;
presol->nchgsides = 0;
presol->ncalls = 0;
presol->wasdelayed = FALSE;
}
/* call initialization method of presolver */
if( presol->presolinit != NULL )
{
/* start timing */
SCIPclockStart(presol->setuptime, set);
SCIP_CALL( presol->presolinit(set->scip, presol) );
/* stop timing */
SCIPclockStop(presol->setuptime, set);
}
presol->initialized = TRUE;
return SCIP_OKAY;
}
/** initializes primal heuristic */
SCIP_RETCODE SCIPheurInit(
SCIP_HEUR* heur, /**< primal heuristic */
SCIP_SET* set /**< global SCIP settings */
)
{
int d;
assert(heur != NULL);
assert(set != NULL);
if( heur->initialized )
{
SCIPerrorMessage("primal heuristic <%s> already initialized\n", heur->name);
return SCIP_INVALIDCALL;
}
if( set->misc_resetstat )
{
SCIPclockReset(heur->setuptime);
SCIPclockReset(heur->heurclock);
heur->delaypos = -1;
heur->ncalls = 0;
heur->nsolsfound = 0;
heur->nbestsolsfound = 0;
}
if( heur->heurinit != NULL )
{
/* start timing */
SCIPclockStart(heur->setuptime, set);
SCIP_CALL( heur->heurinit(set->scip, heur) );
/* stop timing */
SCIPclockStop(heur->setuptime, set);
}
/* reset dive sets */
for( d = 0; d < heur->ndivesets; ++d )
{
assert(heur->divesets[d] != NULL);
SCIPdivesetReset(heur->divesets[d]);
}
heur->initialized = TRUE;
return SCIP_OKAY;
}
/** initializes variable pricer */
SCIP_RETCODE SCIPpricerInit(
SCIP_PRICER* pricer, /**< variable pricer */
SCIP_SET* set /**< global SCIP settings */
)
{
assert(pricer != NULL);
assert(pricer->active);
assert(set != NULL);
if( pricer->initialized )
{
SCIPerrorMessage("variable pricer <%s> already initialized\n", pricer->name);
return SCIP_INVALIDCALL;
}
if( set->misc_resetstat )
{
SCIPclockReset(pricer->pricerclock);
pricer->ncalls = 0;
pricer->nvarsfound = 0;
}
if( pricer->pricerinit != NULL )
{
SCIP_CALL( pricer->pricerinit(set->scip, pricer) );
}
pricer->initialized = TRUE;
return SCIP_OKAY;
}
/** initializes separator */
SCIP_RETCODE SCIPsepaInit(
SCIP_SEPA* sepa, /**< separator */
SCIP_SET* set /**< global SCIP settings */
)
{
assert(sepa != NULL);
assert(set != NULL);
if( sepa->initialized )
{
SCIPerrorMessage("separator <%s> already initialized\n", sepa->name);
return SCIP_INVALIDCALL;
}
if( set->misc_resetstat )
{
SCIPclockReset(sepa->setuptime);
SCIPclockReset(sepa->sepaclock);
sepa->lastsepanode = -1;
sepa->ncalls = 0;
sepa->ncutoffs = 0;
sepa->ncutsfound = 0;
sepa->ncutsapplied = 0;
sepa->nconssfound = 0;
sepa->ndomredsfound = 0;
sepa->ncallsatnode = 0;
sepa->ncutsfoundatnode = 0;
sepa->lpwasdelayed = FALSE;
sepa->solwasdelayed = FALSE;
}
if( sepa->sepainit != NULL )
{
/* start timing */
SCIPclockStart(sepa->setuptime, set);
SCIP_CALL( sepa->sepainit(set->scip, sepa) );
/* stop timing */
SCIPclockStop(sepa->setuptime, set);
}
sepa->initialized = TRUE;
return SCIP_OKAY;
}
/** resets reading time of reader */
SCIP_RETCODE SCIPreaderResetReadingTime(
SCIP_READER* reader /**< reader */
)
{
assert(reader != NULL);
/* reset reading time/clock */
SCIPclockReset(reader->readingtime);
return SCIP_OKAY;
}
/** initializes tree compression */
SCIP_RETCODE SCIPcomprInit(
SCIP_COMPR* compr, /**< tree compression */
SCIP_SET* set /**< global SCIP settings */
)
{
assert(compr != NULL);
assert(set != NULL);
if( compr->initialized )
{
SCIPerrorMessage("tree compression <%s> already initialized\n", compr->name);
return SCIP_INVALIDCALL;
}
if( set->misc_resetstat && !set->reopt_enable )
{
SCIPclockReset(compr->setuptime);
SCIPclockReset(compr->comprclock);
compr->ncalls = 0;
compr->nfound = 0;
}
if( compr->comprinit != NULL )
{
/* start timing */
SCIPclockStart(compr->setuptime, set);
SCIP_CALL( compr->comprinit(set->scip, compr) );
/* stop timing */
SCIPclockStop(compr->setuptime, set);
}
compr->initialized = TRUE;
return SCIP_OKAY;
}
/** initializes relaxation handler */
SCIP_RETCODE SCIPrelaxInit(
SCIP_RELAX* relax, /**< relaxation handler */
SCIP_SET* set /**< global SCIP settings */
)
{
assert(relax != NULL);
assert(set != NULL);
if( relax->initialized )
{
SCIPerrorMessage("relaxation handler <%s> already initialized\n", relax->name);
return SCIP_INVALIDCALL;
}
if( set->misc_resetstat )
{
SCIPclockReset(relax->setuptime);
SCIPclockReset(relax->relaxclock);
relax->ncalls = 0;
relax->lastsolvednode = -1;
}
if( relax->relaxinit != NULL )
{
/* start timing */
SCIPclockStart(relax->setuptime, set);
SCIP_CALL( relax->relaxinit(set->scip, relax) );
/* stop timing */
SCIPclockStop(relax->setuptime, set);
}
relax->initialized = TRUE;
return SCIP_OKAY;
}
/** reset statistics to the data before solving started */
void SCIPstatReset(
SCIP_STAT* stat, /**< problem statistics data */
SCIP_SET* set /**< global SCIP settings */
)
{
assert(stat != NULL);
assert(stat->marked_nvaridx >= 0);
assert(stat->marked_ncolidx >= 0);
assert(stat->marked_nrowidx >= 0);
SCIPclockReset(stat->solvingtime);
SCIPclockReset(stat->presolvingtime);
SCIPclockReset(stat->primallptime);
SCIPclockReset(stat->duallptime);
SCIPclockReset(stat->lexduallptime);
SCIPclockReset(stat->barrierlptime);
SCIPclockReset(stat->divinglptime);
SCIPclockReset(stat->strongbranchtime);
SCIPclockReset(stat->conflictlptime);
SCIPclockReset(stat->lpsoltime);
SCIPclockReset(stat->pseudosoltime);
SCIPclockReset(stat->sbsoltime);
SCIPclockReset(stat->nodeactivationtime);
SCIPclockReset(stat->nlpsoltime);
SCIPclockReset(stat->copyclock);
SCIPclockReset(stat->strongpropclock);
SCIPhistoryReset(stat->glbhistory);
stat->vsidsweight = 1.0;
stat->nlpiterations = 0;
stat->nrootlpiterations = 0;
stat->nrootfirstlpiterations = 0;
stat->nprimallpiterations = 0;
stat->nduallpiterations = 0;
stat->nlexduallpiterations = 0;
stat->nbarrierlpiterations = 0;
stat->nprimalresolvelpiterations = 0;
stat->ndualresolvelpiterations = 0;
stat->nlexdualresolvelpiterations = 0;
stat->nnodelpiterations = 0;
stat->ninitlpiterations = 0;
stat->ndivinglpiterations = 0;
stat->nsbdivinglpiterations = 0;
stat->nsblpiterations = 0;
stat->nrootsblpiterations = 0;
stat->nconflictlpiterations = 0;
stat->ntotalnodes = 0;
stat->ntotalinternalnodes = 0;
stat->ncreatednodes = 0;
stat->nlpsolsfound = 0;
stat->npssolsfound = 0;
stat->nsbsolsfound = 0;
stat->nexternalsolsfound = 0;
stat->domchgcount = 0;
stat->nboundchgs = 0;
stat->nholechgs = 0;
stat->nprobboundchgs = 0;
stat->nprobholechgs = 0;
stat->nsbdowndomchgs = 0;
stat->nsbupdomchgs = 0;
stat->nruns = 0;
stat->nconfrestarts = 0;
stat->nrootboundchgs = 0;
stat->nrootintfixings = 0;
stat->prevrunnvars = 0;
stat->nvaridx = stat->marked_nvaridx;
stat->ncolidx = stat->marked_ncolidx;
stat->nrowidx = stat->marked_nrowidx;
stat->lpcount = 0;
stat->nlps = 0;
stat->nrootlps = 0;
stat->nprimallps = 0;
stat->nprimalzeroitlps = 0;
stat->nduallps = 0;
stat->ndualzeroitlps = 0;
stat->nlexduallps = 0;
stat->nbarrierlps = 0;
stat->nbarrierzeroitlps = 0;
stat->nprimalresolvelps = 0;
stat->ndualresolvelps = 0;
stat->nlexdualresolvelps = 0;
stat->nnodelps = 0;
stat->ninitlps = 0;
stat->ndivinglps = 0;
stat->nsbdivinglps = 0;
stat->nstrongbranchs = 0;
stat->nrootstrongbranchs = 0;
stat->nconflictlps = 0;
stat->nnlps = 0;
stat->maxtotaldepth = -1;
stat->nactiveconss = 0;
stat->nenabledconss = 0;
stat->solindex = 0;
stat->memsavemode = FALSE;
stat->nnodesbeforefirst = -1;
stat->ninitconssadded = 0;
stat->nrunsbeforefirst = -1;
stat->firstprimalheur = NULL;
stat->firstprimaltime = SCIP_DEFAULT_INFINITY;
stat->firstprimalbound = SCIP_DEFAULT_INFINITY;
stat->firstsolgap = SCIP_DEFAULT_INFINITY;
stat->lastsolgap = SCIP_DEFAULT_INFINITY;
stat->primalzeroittime = 0.0;
stat->dualzeroittime = 0.0;
stat->barrierzeroittime = 0.0;
stat->maxcopytime = SCIP_REAL_MIN;
stat->mincopytime = SCIP_REAL_MAX;
stat->firstlptime = 0.0;
stat->firstlpdualbound = SCIP_UNKNOWN;
stat->ncopies = 0;
stat->marked_nvaridx = -1;
stat->marked_ncolidx = -1;
stat->marked_nrowidx = -1;
SCIPstatResetImplications(stat);
SCIPstatResetPresolving(stat);
SCIPstatResetPrimalDualIntegral(stat, set, FALSE);
}