/** calls exit method of primal heuristic */
SCIP_RETCODE SCIPheurExit(
SCIP_HEUR* heur, /**< primal heuristic */
SCIP_SET* set /**< global SCIP settings */
)
{
assert(heur != NULL);
assert(set != NULL);
if( !heur->initialized )
{
SCIPerrorMessage("primal heuristic <%s> not initialized\n", heur->name);
return SCIP_INVALIDCALL;
}
if( heur->heurexit != NULL )
{
/* start timing */
SCIPclockStart(heur->setuptime, set);
SCIP_CALL( heur->heurexit(set->scip, heur) );
/* stop timing */
SCIPclockStop(heur->setuptime, set);
}
heur->initialized = FALSE;
return SCIP_OKAY;
}
/** calls exit method of tree compression */
SCIP_RETCODE SCIPcomprExit(
SCIP_COMPR* compr, /**< tree compression */
SCIP_SET* set /**< global SCIP settings */
)
{
assert(compr != NULL);
assert(set != NULL);
if( !compr->initialized )
{
SCIPerrorMessage("tree compression <%s> not initialized\n", compr->name);
return SCIP_INVALIDCALL;
}
if( compr->comprexit != NULL )
{
/* start timing */
SCIPclockStart(compr->setuptime, set);
SCIP_CALL( compr->comprexit(set->scip, compr) );
/* stop timing */
SCIPclockStop(compr->setuptime, set);
}
compr->initialized = FALSE;
return SCIP_OKAY;
}
/** deinitializes presolver */
SCIP_RETCODE SCIPpresolExit(
SCIP_PRESOL* presol, /**< presolver */
SCIP_SET* set /**< global SCIP settings */
)
{
assert(presol != NULL);
assert(set != NULL);
if( !presol->initialized )
{
SCIPerrorMessage("presolver <%s> not initialized\n", presol->name);
return SCIP_INVALIDCALL;
}
/* call deinitialization method of presolver */
if( presol->presolexit != NULL )
{
/* start timing */
SCIPclockStart(presol->setuptime, set);
SCIP_CALL( presol->presolexit(set->scip, presol) );
/* stop timing */
SCIPclockStop(presol->setuptime, set);
}
presol->initialized = FALSE;
return SCIP_OKAY;
}
/** calls exit method of relaxation handler */
SCIP_RETCODE SCIPrelaxExit(
SCIP_RELAX* relax, /**< relaxation handler */
SCIP_SET* set /**< global SCIP settings */
)
{
assert(relax != NULL);
assert(set != NULL);
if( !relax->initialized )
{
SCIPerrorMessage("relaxation handler <%s> not initialized\n", relax->name);
return SCIP_INVALIDCALL;
}
if( relax->relaxexit != NULL )
{
/* start timing */
SCIPclockStart(relax->setuptime, set);
SCIP_CALL( relax->relaxexit(set->scip, relax) );
/* stop timing */
SCIPclockStop(relax->setuptime, set);
}
relax->initialized = FALSE;
return SCIP_OKAY;
}
/** informs presolver that the presolving process is being started */
SCIP_RETCODE SCIPpresolInitpre(
SCIP_PRESOL* presol, /**< presolver */
SCIP_SET* set /**< global SCIP settings */
)
{
assert(presol != NULL);
assert(set != NULL);
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->wasdelayed = FALSE;
/* call presolving initialization method of presolver */
if( presol->presolinitpre != NULL )
{
/* start timing */
SCIPclockStart(presol->setuptime, set);
SCIP_CALL( presol->presolinitpre(set->scip, presol) );
/* stop timing */
SCIPclockStop(presol->setuptime, set);
}
return SCIP_OKAY;
}
/** informs primal heuristic that the branch and bound process is being started */
SCIP_RETCODE SCIPheurInitsol(
SCIP_HEUR* heur, /**< primal heuristic */
SCIP_SET* set /**< global SCIP settings */
)
{
assert(heur != NULL);
assert(set != NULL);
if( heur->delaypos != -1 )
{
heur->delaypos = -1;
set->heurssorted = FALSE;
}
/* call solving process initialization method of primal heuristic */
if( heur->heurinitsol != NULL )
{
/* start timing */
SCIPclockStart(heur->setuptime, set);
SCIP_CALL( heur->heurinitsol(set->scip, heur) );
/* stop timing */
SCIPclockStop(heur->setuptime, set);
}
return SCIP_OKAY;
}
/** calls exit method of separator */
SCIP_RETCODE SCIPsepaExit(
SCIP_SEPA* sepa, /**< separator */
SCIP_SET* set /**< global SCIP settings */
)
{
assert(sepa != NULL);
assert(set != NULL);
if( !sepa->initialized )
{
SCIPerrorMessage("separator <%s> not initialized\n", sepa->name);
return SCIP_INVALIDCALL;
}
if( sepa->sepaexit != NULL )
{
/* start timing */
SCIPclockStart(sepa->setuptime, set);
SCIP_CALL( sepa->sepaexit(set->scip, sepa) );
/* stop timing */
SCIPclockStop(sepa->setuptime, set);
}
sepa->initialized = FALSE;
return SCIP_OKAY;
}
/** informs separator that the branch and bound process is being started */
SCIP_RETCODE SCIPsepaInitsol(
SCIP_SEPA* sepa, /**< separator */
SCIP_SET* set /**< global SCIP settings */
)
{
assert(sepa != NULL);
assert(set != NULL);
sepa->lpwasdelayed = FALSE;
sepa->solwasdelayed = FALSE;
/* call solving process initialization method of separator */
if( sepa->sepainitsol != NULL )
{
/* start timing */
SCIPclockStart(sepa->setuptime, set);
SCIP_CALL( sepa->sepainitsol(set->scip, sepa) );
/* stop timing */
SCIPclockStop(sepa->setuptime, set);
}
return SCIP_OKAY;
}
/** 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;
}
/** calls execution method of tree compression */
SCIP_RETCODE SCIPcomprExec(
SCIP_COMPR* compr, /**< tree compression */
SCIP_SET* set, /**< global SCIP settings */
SCIP_REOPT* reopt, /**< reoptimization data structure */
SCIP_RESULT* result /**< pointer to store the result of the callback method */
)
{
assert(compr != NULL);
assert(compr->comprexec != NULL);
assert(set != NULL);
assert(set->scip != NULL);
assert(result != NULL);
*result = SCIP_DIDNOTRUN;
/* do not run if reoptimization data structure is not initialized */
if( reopt == NULL )
return SCIP_OKAY;
/* do not run if the reoptimization tree is not large enough */
if( SCIPreoptGetNLeaves(reopt, NULL) < compr->minnnodes )
return SCIP_OKAY;
SCIPdebugMessage("executing tree compression <%s>\n", compr->name);
/* start timing */
SCIPclockStart(compr->comprclock, set);
/* call external method */
SCIP_CALL( compr->comprexec(set->scip, compr, result) );
/* stop timing */
SCIPclockStop(compr->comprclock, set);
/* evaluate result */
if( *result != SCIP_SUCCESS
&& *result != SCIP_DIDNOTFIND
&& *result != SCIP_DIDNOTRUN )
{
SCIPerrorMessage("execution method of tree compression <%s> returned invalid result <%d>\n",
compr->name, *result);
return SCIP_INVALIDRESULT;
}
if( *result != SCIP_DIDNOTRUN )
compr->ncalls++;
if( *result == SCIP_SUCCESS )
compr->nfound++;
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 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;
}
/** informs presolver that the presolving process is finished */
SCIP_RETCODE SCIPpresolExitpre(
SCIP_PRESOL* presol, /**< presolver */
SCIP_SET* set /**< global SCIP settings */
)
{
assert(presol != NULL);
assert(set != NULL);
/* call presolving deinitialization method of presolver */
if( presol->presolexitpre != NULL )
{
/* start timing */
SCIPclockStart(presol->setuptime, set);
SCIP_CALL( presol->presolexitpre(set->scip, presol) );
/* stop timing */
SCIPclockStop(presol->setuptime, set);
}
return SCIP_OKAY;
}
/** informs primal heuristic that the branch and bound process data is being freed */
SCIP_RETCODE SCIPheurExitsol(
SCIP_HEUR* heur, /**< primal heuristic */
SCIP_SET* set /**< global SCIP settings */
)
{
assert(heur != NULL);
assert(set != NULL);
/* call solving process deinitialization method of primal heuristic */
if( heur->heurexitsol != NULL )
{
/* start timing */
SCIPclockStart(heur->setuptime, set);
SCIP_CALL( heur->heurexitsol(set->scip, heur) );
/* stop timing */
SCIPclockStop(heur->setuptime, set);
}
return SCIP_OKAY;
}
/** informs relaxation handler that the branch and bound process data is being freed */
SCIP_RETCODE SCIPrelaxExitsol(
SCIP_RELAX* relax, /**< relaxation handler */
SCIP_SET* set /**< global SCIP settings */
)
{
assert(relax != NULL);
assert(set != NULL);
/* call solving process deinitialization method of relaxation handler */
if( relax->relaxexitsol != NULL )
{
/* start timing */
SCIPclockStart(relax->setuptime, set);
SCIP_CALL( relax->relaxexitsol(set->scip, relax) );
/* stop timing */
SCIPclockStop(relax->setuptime, set);
}
return SCIP_OKAY;
}
/** calls reduced cost pricing method of variable pricer */
SCIP_RETCODE SCIPpricerRedcost(
SCIP_PRICER* pricer, /**< variable pricer */
SCIP_SET* set, /**< global SCIP settings */
SCIP_PROB* prob, /**< transformed problem */
SCIP_Real* lowerbound, /**< local lower bound computed by the pricer */
SCIP_RESULT* result /**< result of the pricing process */
)
{
int oldnvars;
assert(pricer != NULL);
assert(pricer->active);
assert(pricer->pricerredcost != NULL);
assert(set != NULL);
assert(prob != NULL);
assert(lowerbound != NULL);
assert(result != NULL);
SCIPdebugMessage("executing reduced cost pricing of variable pricer <%s>\n", pricer->name);
oldnvars = prob->nvars;
/* start timing */
SCIPclockStart(pricer->pricerclock, set);
/* call external method */
SCIP_CALL( pricer->pricerredcost(set->scip, pricer, lowerbound, result) );
/* stop timing */
SCIPclockStop(pricer->pricerclock, set);
/* evaluate result */
pricer->ncalls++;
pricer->nvarsfound += prob->nvars - oldnvars;
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;
}
/** calls Farkas pricing method of variable pricer */
SCIP_RETCODE SCIPpricerFarkas(
SCIP_PRICER* pricer, /**< variable pricer */
SCIP_SET* set, /**< global SCIP settings */
SCIP_PROB* prob /**< transformed problem */
)
{
int oldnvars;
assert(pricer != NULL);
assert(pricer->active);
assert(set != NULL);
assert(prob != NULL);
/* check, if pricer implemented a Farkas pricing algorithm */
if( pricer->pricerfarkas == NULL )
return SCIP_OKAY;
SCIPdebugMessage("executing Farkas pricing of variable pricer <%s>\n", pricer->name);
oldnvars = prob->nvars;
/* start timing */
SCIPclockStart(pricer->pricerclock, set);
/* call external method */
SCIP_CALL( pricer->pricerfarkas(set->scip, pricer) );
/* stop timing */
SCIPclockStop(pricer->pricerclock, set);
/* evaluate result */
pricer->ncalls++;
pricer->nvarsfound += prob->nvars - oldnvars;
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;
}
/** adds problem variables with negative reduced costs to pricing storage */
SCIP_RETCODE SCIPpricestoreAddProbVars(
SCIP_PRICESTORE* pricestore, /**< pricing storage */
BMS_BLKMEM* blkmem, /**< block memory buffers */
SCIP_SET* set, /**< global SCIP settings */
SCIP_STAT* stat, /**< dynamic problem statistics */
SCIP_PROB* prob, /**< transformed problem after presolve */
SCIP_TREE* tree, /**< branch and bound tree */
SCIP_LP* lp, /**< LP data */
SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
SCIP_EVENTQUEUE* eventqueue /**< event queue */
)
{
SCIP_VAR* var;
SCIP_COL* col;
SCIP_Bool root;
SCIP_Bool added;
int v;
int abortpricevars;
int maxpricevars;
int nfoundvars;
assert(pricestore != NULL);
assert(set != NULL);
assert(stat != NULL);
assert(prob != NULL);
assert(lp != NULL);
assert(lp->solved);
assert(tree != NULL);
assert(SCIPtreeHasCurrentNodeLP(tree));
assert(prob->nvars >= SCIPlpGetNCols(lp));
/* if all problem variables of status COLUMN are already in the LP, nothing has to be done */
if( prob->ncolvars == SCIPlpGetNCols(lp) )
return SCIP_OKAY;
root = (SCIPtreeGetCurrentDepth(tree) == 0);
maxpricevars = SCIPsetGetPriceMaxvars(set, root);
assert(maxpricevars >= 1);
abortpricevars = (int)(set->price_abortfac * maxpricevars);
assert(abortpricevars >= maxpricevars);
/**@todo test pricing: is abortpricevars a good idea? -> like strong branching, lookahead, ... */
pricestore->nprobpricings++;
/* start timing */
SCIPclockStart(pricestore->probpricingtime, set);
/* price already existing problem variables */
nfoundvars = 0;
for( v = 0; v < prob->nvars && nfoundvars < abortpricevars; ++v )
{
var = prob->vars[v];
if( SCIPvarGetStatus(var) == SCIP_VARSTATUS_COLUMN )
{
col = SCIPvarGetCol(var);
assert(col != NULL);
assert(col->var == var);
assert(col->len >= 0);
assert(col->lppos >= -1);
assert(col->lpipos >= -1);
assert(SCIPcolIsInLP(col) == (col->lpipos >= 0));
if( !SCIPcolIsInLP(col) )
{
SCIPdebugMessage("price column variable <%s> in bounds [%g,%g]\n",
SCIPvarGetName(var), SCIPvarGetLbLocal(var), SCIPvarGetUbLocal(var));
/* add variable to pricing storage, if zero is not best bound w.r.t. objective function */
SCIP_CALL( addBoundViolated(pricestore, blkmem, set, stat, tree, lp, branchcand, eventqueue, var, &added) );
if( added )
{
pricestore->nprobvarsfound++;
nfoundvars++;
}
else if( SCIPcolGetNNonz(col) > 0 )
{
SCIP_Real feasibility;
/* a column not in LP that doesn't have zero in its bounds was added by bound checking above */
assert(!SCIPsetIsPositive(set, SCIPvarGetLbLocal(col->var)));
assert(!SCIPsetIsNegative(set, SCIPvarGetUbLocal(col->var)));
if( SCIPlpGetSolstat(lp) == SCIP_LPSOLSTAT_INFEASIBLE )
{
/* The LP was proven infeasible, so we have an infeasibility proof by the dual Farkas multipliers y.
* The valid inequality y^T A x >= y^T b is violated by all x, especially by the (for this
* inequality most feasible solution) x' defined by
* x'_i = ub_i, if y^T A_i > 0
* x'_i = lb_i, if y^T A_i <= 0.
* Pricing in this case means to add variables i with positive Farkas value, i.e. y^T A_i x'_i > 0
*/
feasibility = -SCIPcolGetFarkasValue(col, stat, lp);
SCIPdebugMessage(" <%s> Farkas feasibility: %e\n", SCIPvarGetName(col->var), feasibility);
}
else
{
/* The dual LP is feasible, and we have a feasible dual solution. Pricing in this case means to
* add variables with negative feasibility, that is
* - positive reduced costs for variables with negative lower bound
* - negative reduced costs for variables with positive upper bound
*/
feasibility = SCIPcolGetFeasibility(col, set, stat, lp);
SCIPdebugMessage(" <%s> reduced cost feasibility: %e\n", SCIPvarGetName(col->var), feasibility);
}
/* the score is -feasibility / (#nonzeros in column + 1) to prefer short columns
* we must add variables with negative feasibility, but in order to not get a too large lower bound
* due to missing columns, we better also add variables, that have a very small feasibility
*/
if( !SCIPsetIsPositive(set, feasibility) )
{
SCIP_CALL( SCIPpricestoreAddVar(pricestore, blkmem, set, eventqueue, lp, var, -feasibility / (col->len+1), root) );
pricestore->nprobvarsfound++;
nfoundvars++;
}
}
}
}
}
/* stop timing */
SCIPclockStop(pricestore->probpricingtime, set);
return SCIP_OKAY;
}
/** 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;
}
/** executes presolver */
SCIP_RETCODE SCIPpresolExec(
SCIP_PRESOL* presol, /**< presolver */
SCIP_SET* set, /**< global SCIP settings */
SCIP_Bool execdelayed, /**< execute presolver even if it is marked to be delayed */
int nrounds, /**< number of presolving rounds already done */
int* nfixedvars, /**< pointer to total number of variables fixed of all presolvers */
int* naggrvars, /**< pointer to total number of variables aggregated of all presolvers */
int* nchgvartypes, /**< pointer to total number of variable type changes of all presolvers */
int* nchgbds, /**< pointer to total number of variable bounds tightened of all presolvers */
int* naddholes, /**< pointer to total number of domain holes added of all presolvers */
int* ndelconss, /**< pointer to total number of deleted constraints of all presolvers */
int* naddconss, /**< pointer to total number of added constraints of all presolvers */
int* nupgdconss, /**< pointer to total number of upgraded constraints of all presolvers */
int* nchgcoefs, /**< pointer to total number of changed coefficients of all presolvers */
int* nchgsides, /**< pointer to total number of changed left/right hand sides of all presolvers */
SCIP_RESULT* result /**< pointer to store the result of the callback method */
)
{
int nnewfixedvars;
int nnewaggrvars;
int nnewchgvartypes;
int nnewchgbds;
int nnewaddholes;
int nnewdelconss;
int nnewaddconss;
int nnewupgdconss;
int nnewchgcoefs;
int nnewchgsides;
assert(presol != NULL);
assert(presol->presolexec != NULL);
assert(set != NULL);
assert(nfixedvars != NULL);
assert(naggrvars != NULL);
assert(nchgvartypes != NULL);
assert(nchgbds != NULL);
assert(naddholes != NULL);
assert(ndelconss != NULL);
assert(naddconss != NULL);
assert(nupgdconss != NULL);
assert(nchgcoefs != NULL);
assert(nchgsides != NULL);
assert(result != NULL);
*result = SCIP_DIDNOTRUN;
/* check number of presolving rounds */
if( presol->maxrounds >= 0 && nrounds >= presol->maxrounds && !presol->wasdelayed )
return SCIP_OKAY;
/* calculate the number of changes since last call */
nnewfixedvars = *nfixedvars - presol->lastnfixedvars;
nnewaggrvars = *naggrvars - presol->lastnaggrvars;
nnewchgvartypes = *nchgvartypes - presol->lastnchgvartypes;
nnewchgbds = *nchgbds - presol->lastnchgbds;
nnewaddholes = *naddholes - presol->lastnaddholes;
nnewdelconss = *ndelconss - presol->lastndelconss;
nnewaddconss = *naddconss - presol->lastnaddconss;
nnewupgdconss = *nupgdconss - presol->lastnupgdconss;
nnewchgcoefs = *nchgcoefs - presol->lastnchgcoefs;
nnewchgsides = *nchgsides - presol->lastnchgsides;
/* remember the number of changes prior to the call of the presolver */
presol->lastnfixedvars = *nfixedvars;
presol->lastnaggrvars = *naggrvars;
presol->lastnchgvartypes = *nchgvartypes;
presol->lastnchgbds = *nchgbds;
presol->lastnaddholes = *naddholes;
presol->lastndelconss = *ndelconss;
presol->lastnaddconss = *naddconss;
presol->lastnupgdconss = *nupgdconss;
presol->lastnchgcoefs = *nchgcoefs;
presol->lastnchgsides = *nchgsides;
/* check, if presolver should be delayed */
if( !presol->delay || execdelayed )
{
SCIPdebugMessage("calling presolver <%s>\n", presol->name);
/* start timing */
SCIPclockStart(presol->presolclock, set);
/* call external method */
SCIP_CALL( presol->presolexec(set->scip, presol, nrounds,
nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewaddholes,
nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides,
nfixedvars, naggrvars, nchgvartypes, nchgbds, naddholes,
ndelconss, naddconss, nupgdconss, nchgcoefs, nchgsides, result) );
/* stop timing */
SCIPclockStop(presol->presolclock, set);
/* add/count the new changes */
presol->nfixedvars += *nfixedvars - presol->lastnfixedvars;
presol->naggrvars += *naggrvars - presol->lastnaggrvars;
presol->nchgvartypes += *nchgvartypes - presol->lastnchgvartypes;
presol->nchgbds += *nchgbds - presol->lastnchgbds;
presol->naddholes += *naddholes - presol->lastnaddholes;
presol->ndelconss += *ndelconss - presol->lastndelconss;
presol->naddconss += *naddconss - presol->lastnaddconss;
presol->nupgdconss += *nupgdconss - presol->lastnupgdconss;
presol->nchgcoefs += *nchgcoefs - presol->lastnchgcoefs;
presol->nchgsides += *nchgsides - presol->lastnchgsides;
/* check result code of callback method */
if( *result != SCIP_CUTOFF
&& *result != SCIP_UNBOUNDED
&& *result != SCIP_SUCCESS
&& *result != SCIP_DIDNOTFIND
&& *result != SCIP_DIDNOTRUN
&& *result != SCIP_DELAYED )
{
SCIPerrorMessage("presolver <%s> returned invalid result <%d>\n", presol->name, *result);
return SCIP_INVALIDRESULT;
}
/* increase the number of calls, if the presolver tried to find reductions */
if( *result != SCIP_DIDNOTRUN && *result != SCIP_DELAYED )
++(presol->ncalls);
}
else
{
SCIPdebugMessage("presolver <%s> was delayed\n", presol->name);
*result = SCIP_DELAYED;
}
/* remember whether presolver was delayed */
presol->wasdelayed = (*result == SCIP_DELAYED);
return SCIP_OKAY;
}
/** calls execution method of primal heuristic */
SCIP_RETCODE SCIPheurExec(
SCIP_HEUR* heur, /**< primal heuristic */
SCIP_SET* set, /**< global SCIP settings */
SCIP_PRIMAL* primal, /**< primal data */
int depth, /**< depth of current node */
int lpstateforkdepth, /**< depth of the last node with solved LP */
SCIP_HEURTIMING heurtiming, /**< current point in the node solving process */
SCIP_Bool nodeinfeasible, /**< was the current node already detected to be infeasible? */
int* ndelayedheurs, /**< pointer to count the number of delayed heuristics */
SCIP_RESULT* result /**< pointer to store the result of the callback method */
)
{
SCIP_Bool execute;
SCIP_Bool delayed;
assert(heur != NULL);
assert(heur->heurexec != NULL);
assert(heur->freq >= -1);
assert(heur->freqofs >= 0);
assert(heur->maxdepth >= -1);
assert(set != NULL);
assert(set->scip != NULL);
assert(primal != NULL);
assert(depth >= 0 || heurtiming == SCIP_HEURTIMING_BEFOREPRESOL || heurtiming == SCIP_HEURTIMING_DURINGPRESOLLOOP);
assert(ndelayedheurs != NULL);
assert(result != NULL);
*result = SCIP_DIDNOTRUN;
delayed = FALSE;
execute = SCIPheurShouldBeExecuted(heur, depth, lpstateforkdepth, heurtiming, &delayed);
if( delayed )
{
assert(!execute);
*result = SCIP_DELAYED;
}
if( execute )
{
SCIP_Longint oldnsolsfound;
SCIP_Longint oldnbestsolsfound;
SCIPdebugMessage("executing primal heuristic <%s> in depth %d (delaypos: %d)\n", heur->name, depth, heur->delaypos);
oldnsolsfound = primal->nsolsfound;
oldnbestsolsfound = primal->nbestsolsfound;
/* start timing */
SCIPclockStart(heur->heurclock, set);
/* call external method */
SCIP_CALL( heur->heurexec(set->scip, heur, heurtiming, nodeinfeasible, result) );
/* stop timing */
SCIPclockStop(heur->heurclock, set);
/* evaluate result */
if( *result != SCIP_FOUNDSOL
&& *result != SCIP_DIDNOTFIND
&& *result != SCIP_DIDNOTRUN
&& *result != SCIP_DELAYED )
{
SCIPerrorMessage("execution method of primal heuristic <%s> returned invalid result <%d>\n",
heur->name, *result);
return SCIP_INVALIDRESULT;
}
if( *result != SCIP_DIDNOTRUN && *result != SCIP_DELAYED )
heur->ncalls++;
heur->nsolsfound += primal->nsolsfound - oldnsolsfound;
heur->nbestsolsfound += primal->nbestsolsfound - oldnbestsolsfound;
/* update delay position of heuristic */
if( *result != SCIP_DELAYED && heur->delaypos != -1 )
{
heur->delaypos = -1;
set->heurssorted = FALSE;
}
}
assert(*result == SCIP_DIDNOTRUN || *result == SCIP_DELAYED || heur->delaypos == -1);
/* check if the heuristic was (still) delayed */
if( *result == SCIP_DELAYED || heur->delaypos >= 0 )
{
SCIPdebugMessage("delaying execution of primal heuristic <%s> in depth %d (delaypos: %d), heur was%s delayed before, had delaypos %d\n",
heur->name, depth, *ndelayedheurs, heur->delaypos >= 0 ? "" : " not", heur->delaypos);
/* mark the heuristic delayed */
if( heur->delaypos != *ndelayedheurs )
{
heur->delaypos = *ndelayedheurs;
set->heurssorted = FALSE;
}
(*ndelayedheurs)++;
}
return SCIP_OKAY;
}
/** calls execution method of relaxation handler */
SCIP_RETCODE SCIPrelaxExec(
SCIP_RELAX* relax, /**< relaxation handler */
SCIP_SET* set, /**< global SCIP settings */
SCIP_STAT* stat, /**< dynamic problem statistics */
int depth, /**< depth of current node */
SCIP_Real* lowerbound, /**< pointer to lower bound computed by the relaxation handler */
SCIP_RESULT* result /**< pointer to store the result of the callback method */
)
{
assert(relax != NULL);
assert(relax->relaxexec != NULL);
assert(relax->freq >= -1);
assert(set != NULL);
assert(set->scip != NULL);
assert(depth >= 0);
assert(result != NULL);
*result = SCIP_DIDNOTRUN;
/* check, if the relaxation is already solved */
if( relax->lastsolvednode == stat->ntotalnodes )
return SCIP_OKAY;
relax->lastsolvednode = stat->ntotalnodes;
if( (depth == 0 && relax->freq == 0) || (relax->freq > 0 && depth % relax->freq == 0) )
{
SCIPdebugMessage("executing relaxation handler <%s>\n", relax->name);
/* start timing */
SCIPclockStart(relax->relaxclock, set);
/* call external relaxation method */
SCIP_CALL( relax->relaxexec(set->scip, relax, lowerbound, result) );
/* stop timing */
SCIPclockStop(relax->relaxclock, set);
/* evaluate result */
if( *result != SCIP_CUTOFF
&& *result != SCIP_CONSADDED
&& *result != SCIP_REDUCEDDOM
&& *result != SCIP_SEPARATED
&& *result != SCIP_SUCCESS
&& *result != SCIP_SUSPENDED
&& *result != SCIP_DIDNOTRUN )
{
SCIPerrorMessage("execution method of relaxation handler <%s> returned invalid result <%d>\n",
relax->name, *result);
return SCIP_INVALIDRESULT;
}
if( *result != SCIP_DIDNOTRUN )
{
relax->ncalls++;
if( *result == SCIP_SUSPENDED )
SCIPrelaxMarkUnsolved(relax);
}
}
return SCIP_OKAY;
}
/** calls primal solution separation method of separator */
SCIP_RETCODE SCIPsepaExecSol(
SCIP_SEPA* sepa, /**< separator */
SCIP_SET* set, /**< global SCIP settings */
SCIP_STAT* stat, /**< dynamic problem statistics */
SCIP_SEPASTORE* sepastore, /**< separation storage */
SCIP_SOL* sol, /**< primal solution that should be separated */
int depth, /**< depth of current node */
SCIP_Bool execdelayed, /**< execute separator even if it is marked to be delayed */
SCIP_RESULT* result /**< pointer to store the result of the callback method */
)
{
assert(sepa != NULL);
assert(sepa->freq >= -1);
assert(set != NULL);
assert(set->scip != NULL);
assert(stat != NULL);
assert(depth >= 0);
assert(result != NULL);
if( sepa->sepaexecsol != NULL
&& ((depth == 0 && sepa->freq == 0) || (sepa->freq > 0 && depth % sepa->freq == 0) || sepa->solwasdelayed) )
{
if( (!sepa->delay && !sepa->solwasdelayed) || execdelayed )
{
SCIP_Longint oldndomchgs;
SCIP_Longint oldnprobdomchgs;
int oldncuts;
int oldnactiveconss;
int ncutsfound;
SCIPdebugMessage("executing separator <%s> on solution %p\n", sepa->name, (void*)sol);
oldndomchgs = stat->nboundchgs + stat->nholechgs;
oldnprobdomchgs = stat->nprobboundchgs + stat->nprobholechgs;
oldncuts = SCIPsepastoreGetNCuts(sepastore);
oldnactiveconss = stat->nactiveconss;
/* reset the statistics for current node */
if( sepa->lastsepanode != stat->ntotalnodes )
{
sepa->ncallsatnode = 0;
sepa->ncutsfoundatnode = 0;
}
/* start timing */
SCIPclockStart(sepa->sepaclock, set);
/* call external separation method */
SCIP_CALL( sepa->sepaexecsol(set->scip, sepa, sol, result) );
/* stop timing */
SCIPclockStop(sepa->sepaclock, set);
/* update statistics */
if( *result != SCIP_DIDNOTRUN && *result != SCIP_DELAYED )
{
sepa->ncalls++;
sepa->ncallsatnode++;
sepa->lastsepanode = stat->ntotalnodes;
}
if( *result == SCIP_CUTOFF )
sepa->ncutoffs++;
ncutsfound = SCIPsepastoreGetNCuts(sepastore) - oldncuts;
sepa->ncutsfound += ncutsfound;
sepa->ncutsfoundatnode += ncutsfound;
sepa->nconssfound += MAX(stat->nactiveconss - oldnactiveconss, 0); /*lint !e776*/
/* update domain reductions; therefore remove the domain
* reduction counts which were generated in probing mode */
sepa->ndomredsfound += stat->nboundchgs + stat->nholechgs - oldndomchgs;
sepa->ndomredsfound -= (stat->nprobboundchgs + stat->nprobholechgs - oldnprobdomchgs);
/* evaluate result */
if( *result != SCIP_CUTOFF
&& *result != SCIP_CONSADDED
&& *result != SCIP_REDUCEDDOM
&& *result != SCIP_SEPARATED
&& *result != SCIP_NEWROUND
&& *result != SCIP_DIDNOTFIND
&& *result != SCIP_DIDNOTRUN
&& *result != SCIP_DELAYED )
{
SCIPerrorMessage("execution method of separator <%s> returned invalid result <%d>\n",
sepa->name, *result);
return SCIP_INVALIDRESULT;
}
}
else
{
SCIPdebugMessage("separator <%s> was delayed\n", sepa->name);
*result = SCIP_DELAYED;
}
/* remember whether separator was delayed */
sepa->solwasdelayed = (*result == SCIP_DELAYED);
}
else
*result = SCIP_DIDNOTRUN;
return SCIP_OKAY;
}
