/** gets time needed to price existing problem variables */
SCIP_Real SCIPpricestoreGetProbPricingTime(
SCIP_PRICESTORE* pricestore /**< pricing storage */
)
{
assert(pricestore != NULL);
return SCIPclockGetTime(pricestore->probpricingtime);
}
/** gets time in seconds used in this reader for reading */
SCIP_Real SCIPreaderGetReadingTime(
SCIP_READER* reader /**< reader */
)
{
assert(reader != NULL);
return SCIPclockGetTime(reader->readingtime);
}
/** gets time in seconds used in this relaxation handler */
SCIP_Real SCIPrelaxGetTime(
SCIP_RELAX* relax /**< relaxation handler */
)
{
assert(relax != NULL);
return SCIPclockGetTime(relax->relaxclock);
}
/** gets time in seconds used in this presolver */
SCIP_Real SCIPpresolGetTime(
SCIP_PRESOL* presol /**< presolver */
)
{
assert(presol != NULL);
return SCIPclockGetTime(presol->presolclock);
}
/** gets time in seconds used in this separator */
SCIP_Real SCIPsepaGetTime(
SCIP_SEPA* sepa /**< separator */
)
{
assert(sepa != NULL);
return SCIPclockGetTime(sepa->sepaclock);
}
/** gets time in seconds used in this relaxator for setting up for next stages */
SCIP_Real SCIPrelaxGetSetupTime(
SCIP_RELAX* relax /**< relaxator */
)
{
assert(relax != NULL);
return SCIPclockGetTime(relax->setuptime);
}
/** gets time in seconds used in this heuristic */
SCIP_Real SCIPcomprGetTime(
SCIP_COMPR* compr /**< tree compression */
)
{
assert(compr != NULL);
return SCIPclockGetTime(compr->comprclock);
}
/** gets time in seconds used in this pricer */
SCIP_Real SCIPpricerGetTime(
SCIP_PRICER* pricer /**< variable pricer */
)
{
assert(pricer != NULL);
return SCIPclockGetTime(pricer->pricerclock);
}
/** gets time in seconds used in this heuristic */
SCIP_Real SCIPheurGetTime(
SCIP_HEUR* heur /**< primal heuristic */
)
{
assert(heur != NULL);
return SCIPclockGetTime(heur->heurclock);
}
/** prints current solution time to visualization output file */
static
void printTime(
SCIP_VISUAL* visual, /**< visualization information */
SCIP_STAT* stat, /**< problem statistics */
SCIP_Bool vbc /**< whether we use vbc output (bak otherwise) */
)
{
SCIP_Longint step;
int hours;
int mins;
int secs;
int hunds;
assert( visual != NULL );
assert( stat != NULL );
if( visual->userealtime )
{
double time;
time = SCIPclockGetTime(stat->solvingtime);
step = (SCIP_Longint)(time * 100.0);
}
else
{
step = visual->timestep;
visual->timestep++;
}
if ( vbc )
{
hours = (int)(step / (60*60*100));
step %= 60*60*100;
mins = (int)(step / (60*100));
step %= 60*100;
secs = (int)(step / 100);
step %= 100;
hunds = (int)step;
SCIPmessageFPrintInfo(visual->messagehdlr, visual->vbcfile, "%02d:%02d:%02d.%02d ", hours, mins, secs, hunds);
}
else
{
SCIPmessageFPrintInfo(visual->messagehdlr, visual->bakfile, "%f ", (SCIP_Real) step/100.0);
}
}
/** prints current solution time to VBC output file */
static
void printTime(
SCIP_VBC* vbc, /**< VBC information */
SCIP_STAT* stat /**< problem statistics */
)
{
SCIP_Longint step;
int hours;
int mins;
int secs;
int hunds;
assert(vbc != NULL);
assert(stat != NULL);
if( vbc->userealtime )
{
double time;
time = SCIPclockGetTime(stat->solvingtime);
step = (SCIP_Longint)(time * 100.0);
}
else
{
step = vbc->timestep;
vbc->timestep++;
}
hours = (int)(step / (60*60*100));
step %= 60*60*100;
mins = (int)(step / (60*100));
step %= 60*100;
secs = (int)(step / 100);
step %= 100;
hunds = (int)step;
SCIPmessageFPrintInfo(vbc->messagehdlr, vbc->file, "%02d:%02d:%02d.%02d ", hours, mins, secs, hunds);
}
double SCIPSolver::getTime(){
return SCIPclockGetTime(_scip->stat->solvingtime);
}
/** reads problem data from file with given reader or returns SCIP_DIDNOTRUN */
SCIP_RETCODE SCIPreaderRead(
SCIP_READER* reader, /**< reader */
SCIP_SET* set, /**< global SCIP settings */
const char* filename, /**< name of the input file */
const char* extension, /**< extension of the input file name */
SCIP_RESULT* result /**< pointer to store the result of the callback method */
)
{
SCIP_RETCODE retcode;
assert(reader != NULL);
assert(set != NULL);
assert(filename != NULL);
assert(result != NULL);
/* check, if reader is applicable on the given file */
if( readerIsApplicable(reader, extension) && reader->readerread != NULL )
{
SCIP_CLOCK* readingtime;
/**@note we need temporary clock to measure the reading time correctly since in case of creating a new problem
* within the reader all clocks are reset (including the reader clocks); this resetting is necessary for
* example for those case we people solve several problems using the (same) interactive shell
*/
assert(!SCIPclockIsRunning(reader->readingtime));
/* create a temporary clock for measuring the reading time */
SCIP_CALL( SCIPclockCreate(&readingtime, SCIP_CLOCKTYPE_DEFAULT) );
/* start timing */
SCIPclockStart(readingtime, set);
/* call reader to read problem */
retcode = reader->readerread(set->scip, reader, filename, result);
/* stop timing */
SCIPclockStop(readingtime, set);
/* add time to reader reading clock */
SCIPclockSetTime(reader->readingtime, SCIPclockGetTime(reader->readingtime) + SCIPclockGetTime(readingtime));
/* free the temporary clock */
SCIPclockFree(&readingtime);
}
else
{
*result = SCIP_DIDNOTRUN;
retcode = SCIP_OKAY;
}
/* check for reader errors */
if( retcode == SCIP_NOFILE || retcode == SCIP_READERROR )
return retcode;
/* check if the result code is valid in case no reader error occurred */
assert( *result == SCIP_DIDNOTRUN || *result == SCIP_SUCCESS );
SCIP_CALL( retcode );
return SCIP_OKAY;
}
/** update the primal-dual integral statistic. method accepts + and - SCIPsetInfinity() as values for
* upper and lower bound, respectively
*/
void SCIPstatUpdatePrimalDualIntegral(
SCIP_STAT* stat, /**< problem statistics data */
SCIP_SET* set, /**< global SCIP settings */
SCIP_PROB* transprob, /**< transformed problem */
SCIP_PROB* origprob, /**< original problem */
SCIP_Real upperbound, /**< current upper bound in transformed problem, or infinity */
SCIP_Real lowerbound /**< current lower bound in transformed space, or -infinity */
)
{
SCIP_Real currentgap;
SCIP_Real solvingtime;
SCIP_Real primalbound;
SCIP_Real dualbound;
assert(stat != NULL);
assert(set != NULL);
solvingtime = SCIPclockGetTime(stat->solvingtime);
assert(solvingtime >= stat->previntegralevaltime);
if( !SCIPsetIsInfinity(set, upperbound) ) /*lint !e777*/
{
/* get value in original space for gap calculation */
primalbound = SCIPprobExternObjval(transprob, origprob, set, upperbound);
if( SCIPsetIsZero(set, primalbound) )
primalbound = 0.0;
}
else
{
/* no new upper bound: use stored values from last update */
upperbound = stat->lastupperbound;
primalbound = stat->lastprimalbound;
assert(SCIPsetIsZero(set, primalbound) == (primalbound == 0.0)); /*lint !e777*/
}
if( !SCIPsetIsInfinity(set, -lowerbound) ) /*lint !e777*/
{
/* get value in original space for gap calculation */
dualbound = SCIPprobExternObjval(transprob, origprob, set, lowerbound);
if( SCIPsetIsZero(set, dualbound) )
dualbound = 0.0;
}
else
{
/* no new lower bound: use stored values from last update */
lowerbound = stat->lastlowerbound;
dualbound = stat->lastdualbound;
assert(SCIPsetIsZero(set, dualbound) == (dualbound == 0.0)); /*lint !e777*/
}
/* computation of the gap, special cases are handled first */
if( primalbound == SCIP_UNKNOWN || dualbound == SCIP_UNKNOWN ) /*lint !e777*/
currentgap = 100.0;
/* the gap is 0.0 if bounds coincide */
else if( SCIPsetIsGE(set, lowerbound, upperbound) || SCIPsetIsEQ(set, primalbound, dualbound) )
currentgap = 0.0;
/* the gap is 100.0 if bounds have different signs */
else if( primalbound * dualbound <= 0.0 ) /*lint !e777*/
currentgap = 100.0;
else if( !SCIPsetIsInfinity(set, REALABS(primalbound)) && !SCIPsetIsInfinity(set, REALABS(dualbound)) )
{
SCIP_Real absprim = REALABS(primalbound);
SCIP_Real absdual = REALABS(dualbound);
/* The gap in the definition of the primal-dual integral differs from the default SCIP gap function.
* Here, the MAX(primalbound, dualbound) is taken for gap quotient in order to ensure a gap <= 100.
*/
currentgap = 100.0 * REALABS(primalbound - dualbound) / MAX(absprim, absdual);
assert(SCIPsetIsLE(set, currentgap, 100.0));
}
else
currentgap = 100.0;
/* if primal and dual bound have opposite signs, the gap always evaluates to 100.0% */
assert(currentgap == 0.0 || currentgap == 100.0 || SCIPsetIsGE(set, primalbound * dualbound, 0.0));
assert(SCIPsetIsGE(set, stat->previousgap, currentgap) || (set->stage == SCIP_STAGE_EXITPRESOLVE
&& SCIPsetIsFeasGE(set, stat->previousgap, currentgap)));
/* update the integral based on previous information */
stat->primaldualintegral += (solvingtime - stat->previntegralevaltime) * stat->previousgap;
/* update all relevant information for next evaluation */
stat->previousgap = currentgap;
stat->previntegralevaltime = solvingtime;
stat->lastprimalbound = primalbound;
stat->lastdualbound = dualbound;
stat->lastlowerbound = lowerbound;
stat->lastupperbound = upperbound;
}
