/** 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; }