pricer_gcg.cpp
Go to the documentation of this file.
38 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
95 #define PRICER_DELAY TRUE /* only call pricer if all problem variables have non-negative reduced costs */
98 #define DEFAULT_ABORTPRICINGGAP 0.00 /**< gap between dual bound and RMP objective at which pricing is aborted */
100 #define DEFAULT_DISABLECUTOFF 2 /**< should the cutoffbound be applied in master LP solving? (0: on, 1:off, 2:auto) */
103 #define DEFAULT_STABILIZATIONTREE FALSE /**< should stabilization be used in nodes other than the root node*/
104 #define DEFAULT_HYBRIDASCENT FALSE /**< should hybridization of smoothing with an ascent method be enabled */
105 #define DEFAULT_HYBRIDASCENT_NOAGG FALSE /**< should hybridization of smoothing with an ascent method be enabled
108 #define DEFAULT_USECOLPOOL TRUE /**< should the colpool be checked for negative redcost cols before solving the pricing problems? */
117 #define DEFAULT_USEARTIFICIALVARS FALSE /**< add artificial vars to master (instead of using Farkas pricing) */
118 #define DEFAULT_USEMAXOBJ TRUE /**< default value for using maxobj for big M objective of artificial variables */
119 #define DEFAULT_ONLYRELIABLEBIGM TRUE /**< default value for only using maxobj for big M objective of artificial variables if it is reliable */
120 #define DEFAULT_FACTORUNRELIABLE 1000 /**< default factor to use for objective of unbounded variables */
121 #define DEFAULT_BIGMARTIFICIAL 1000 /**< default value for big M objective of artificial variables (if maxobj is not used)*/
135 #define PRICER_STAT_ARRAYLEN_TIME 1024 /**< length of the array for Time histogram representation */
136 #define PRICER_STAT_BUCKETSIZE_TIME 10 /**< size of the buckets for Time histogram representation */
137 #define PRICER_STAT_ARRAYLEN_VARS 1024 /**< length of the array for foundVars histogram representation */
138 #define PRICER_STAT_BUCKETSIZE_VARS 1 /**< size of the buckets for foundVars histogram representation */
156 SCIP_HASHMAP* mapcons2idx; /**< hashmap mapping constraints to their index in the conss array */
166 SCIP_Bool artificialused; /**< returns if artificial variables are used in current node's LP solution */
192 int disablecutoff; /**< should the cutoffbound be applied in master LP solving (0: on, 1:off, 2:auto)? */
193 SCIP_Real abortpricinggap; /**< gap between dual bound and RMP objective at which pricing is aborted */
195 SCIP_Bool stabilizationtree; /**< should stabilization be used in nodes other than the root node */
196 SCIP_Bool usecolpool; /**< should the colpool be checked for negative redcost cols before solving the pricing problems? */
197 SCIP_Bool useartificialvars; /**< use artificial variables to make RMP feasible (instead of applying Farkas pricing) */
198 SCIP_Real maxobj; /**< maxobj bound that can be used for big M objective of artificial variables */
200 SCIP_Bool onlyreliablebigm; /**< only use maxobj for big M objective of artificial variables if it is reliable */
202 SCIP_Real bigmartificial; /**< value for for big M objective of artificial variables (if maxobj is not used) */
203 SCIP_Bool hybridascent; /**< should hybridization of smoothing with an ascent method be enabled */
204 SCIP_Bool hybridascentnoagg; /**< should hybridization of smoothing with an ascent method be enabled
233 SCIP_Real* rootpbs; /**< array of primal bounds for the root LP, one bound for each pricing call */
234 SCIP_Real* rootdbs; /**< array of dual bounds for the root LP, one bound for each pricing call */
240 int dualdiffround; /**< value of nrootbounds when difference to last dual solution was computed */
242 SCIP_Real*** dualvalues; /**< array of dual values for pricing variables for each root redcost call*/
243 SCIP_Real** dualsolconvs; /**< array of dual solutions for the convexity constraints for each root redcost call*/
281 /** solving process initialization method of event handler (called when branch and bound process is about to begin) */
284 /** solving process deinitialization method of event handler (called before branch and bound process data is freed) */
310 SCIPdebugMessage("remove master variable %s from pricerdata and corresponding original variables\n", SCIPvarGetName(var));
332 SCIPdropVarEvent(scip, pricerdata->pricedvars[i], SCIP_EVENTTYPE_VARDELETED, pricerdata->eventhdlr, NULL, -1));
336 assert(pricerdata->pricedvars[pricerdata->npricedvars] != NULL || i == pricerdata->npricedvars);
374 /** get the number of columns per pricing problem to be added to the master LP in the current pricing round */
394 SCIP_CALL( SCIPreallocBlockMemoryArray(scip_, &(pricerdata->pricedvars), oldsize, pricerdata->maxpricedvars) );
420 SCIP_CALL( SCIPreallocBlockMemoryArray(scip_, &(pricerdata->rootpbs), oldsize, pricerdata->maxrootbounds) );
421 SCIP_CALL( SCIPreallocBlockMemoryArray(scip_, &(pricerdata->rootdbs), oldsize, pricerdata->maxrootbounds) );
422 SCIP_CALL( SCIPreallocBlockMemoryArray(scip_, &(pricerdata->roottimes), oldsize, pricerdata->maxrootbounds) );
423 SCIP_CALL( SCIPreallocBlockMemoryArray(scip_, &(pricerdata->rootdualdiffs), oldsize, pricerdata->maxrootbounds) );
424 SCIP_CALL( SCIPreallocBlockMemoryArray(scip_, &(pricerdata->dualvalues), oldsize, pricerdata->maxrootbounds) );
425 SCIP_CALL( SCIPreallocBlockMemoryArray(scip_, &(pricerdata->dualsolconvs), oldsize, pricerdata->maxrootbounds) );
639 if (SCIPisEQ(scip_, currentVal, SCIPcolGetLb(col)) || SCIPisEQ(scip_, currentVal, SCIPcolGetUb(col)))
647 if (SCIPisEQ(scip_, currentVal, SCIProwGetRhs(row)) || SCIPisEQ(scip_, currentVal, SCIProwGetLhs(row)))
679 memlimit -= SCIPgetMemUsed(origprob)/1048576.0 + GCGgetPricingprobsMemUsed(origprob) - SCIPgetMemUsed(pricingscip)/1048576.0;
689 /** for a pricing problem, get the dual solution value or Farkas value of the convexity constraint */
730 /* get the constraints of the master problem and the corresponding constraints in the original problem */
748 assert( GCGoriginalVarIsLinking(GCGpricingVarGetOrigvars(probvars[j])[0]) || (GCGvarGetBlock(GCGpricingVarGetOrigvars(probvars[j])[0]) == i));
750 SCIP_CALL( SCIPchgVarObj(pricerdata->pricingprobs[i], probvars[j], pricetype->varGetObj(probvars[j])));
754 SCIPdebugMessage("pricingobj var <%s> %f, realdualvalues %f\n", SCIPvarGetName(probvars[j]), pricetype->varGetObj(probvars[j]), pricerdata->realdualvalues[i][j]);
759 /* compute reduced cost for linking variable constraints and update objectives in the pricing problems
795 assert(SCIPvarGetProbindex(pricingvar) >= 0 && SCIPvarGetProbindex(pricingvar) < SCIPgetNVars(pricerdata->pricingprobs[block]));
796 pricerdata->realdualvalues[block][SCIPvarGetProbindex(pricingvar)] += pricetype->consGetDual(scip_, linkcons);
799 SCIPdebugMessage("pricingobj var <%s> %f, realdualvalues %f\n", SCIPvarGetName(pricingvar), dualsol, pricetype->consGetDual(scip_, linkcons));
815 if( !SCIPisZero(scip_, dualsol) || !SCIPisZero(scip_, pricetype->consGetDual(scip_, masterconss[i])) )
821 /* for all variables in the constraint, modify the objective of the corresponding variable in a pricing problem */
832 /* nothing to be done if variable belongs to redundant block or variable was directly transferred to the master
833 * or variable is linking variable (which means, the directly transferred copy is part of the master cons)
842 pricerdata->realdualvalues[blocknr][SCIPvarGetProbindex(GCGoriginalVarGetPricingVar(consvars[j]))] += -1.0 * consvals[j] * pricetype->consGetDual(scip_, masterconss[i]);
846 SCIPvarGetName(GCGoriginalVarGetPricingVar(consvars[j])), dualsol, -1.0 * consvals[j] * pricetype->consGetDual(scip_, masterconss[i]));
887 /* for all variables in the cut, modify the objective of the corresponding variable in a pricing problem */
895 * or variable is linking variable (which means, the directly transferred copy is part of the master cut) */
903 pricerdata->realdualvalues[blocknr][SCIPvarGetProbindex(GCGoriginalVarGetPricingVar(consvars[j]))] += -1.0 *consvals[j]* pricetype->rowGetDual(mastercuts[i]);
907 SCIPvarGetName(GCGoriginalVarGetPricingVar(consvars[j])), dualsol, -1.0 * consvals[j] * pricetype->rowGetDual(mastercuts[i]));
931 SCIPdebugMessage("convcons <%s> dualsol: %g\n", SCIPconsGetName(GCGgetConvCons(origprob, i)), pricerdata->dualsolconv[i]);
943 SCIP_VAR** solvars, /**< array of variables with non-zero value in the solution of the pricing problem */
944 SCIP_Real* solvals, /**< array of values in the solution of the pricing problem for variables in array solvars*/
1002 /* for each coef, add coef * solval to the coef of the new variable for the corresponding constraint */
1044 SCIP_VAR** solvars; /* array of variables with non-zero value in the solution of the pricing problem */
1045 SCIP_Real* solvals; /* array of values in the solution of the pricing problem for variables in array solvars*/
1149 // SCIPdebugMessage("Coefficients already computed, nmastercoefs = %d\n", GCGcolGetNMastercoefs(gcgcol));
1190 /* for each coef, add coef * solval to the coef of the new variable for the corresponding constraint */
1224 SCIP_VAR** solvars, /**< array of variables with non-zero value in the solution of the pricing problem */
1225 SCIP_Real* solvals, /**< array of values in the solution of the pricing problem for variables in array solvars*/
1445 /** adds new bounds to the bound arrays as well as some additional information on dual variables and root lp solution */
1466 pricerdata->roottimes[pricerdata->nrootbounds] = SCIPgetSolvingTime(scip_) - pricerdata->rootfarkastime;
1471 SCIP_CALL( SCIPallocBlockMemoryArray(scip_, &pricerdata->dualvalues[pricerdata->nrootbounds], pricerdata->npricingprobs) );
1472 SCIP_CALL( SCIPallocBlockMemoryArray(scip_, &pricerdata->dualsolconvs[pricerdata->nrootbounds], pricerdata->npricingprobs) );
1482 SCIP_CALL( SCIPallocBlockMemoryArray(scip_, &(pricerdata->dualvalues[pricerdata->nrootbounds][i]), nprobvars) );
1562 /* compute reduced cost of variable (i.e. subtract dual solution of convexity constraint, if solution corresponds to a point) */
1642 SCIPdebugMessage(" -> column %d/%d <%p>, reduced cost = %g\n", i+1, ncols, (void*) cols[i], redcost);
1693 || SCIPisDualfeasLT(scip_, GCGcolGetRedcost(cols[i]), GCGcolGetRedcost(pricingprobcols[probnr])) )
1709 if( GCGisPricingprobRelevant(origprob, i) && (bestcols[i] == NULL || !GCGcolIsRay(bestcols[i])) )
1710 dualconvsum += GCGgetNIdenticalBlocks(origprob, i) * pricingtype->consGetDual(scip_, GCGgetConvCons(origprob, i));
1716 /* computes the objective value of the current (stabilized) dual variables) in the dual program */
1757 /* get the constraints of the master problem and the corresponding constraints in the original problem */
1785 assert(GCGvarIsPricing(GCGlinkingVarGetPricingVars(GCGmasterVarGetOrigvars(linkvar)[0])[block]));
1866 assert( GCGoriginalVarIsLinking(GCGmasterVarGetOrigvars(mastervars[i])[0]) || GCGoriginalVarIsTransVar(GCGmasterVarGetOrigvars(mastervars[i])[0]) );
1871 /* compute reduced cost for linking variable constraints and update (stabilized) reduced cost coefficients
1905 /* compute reduced cost for master constraints and update (stabilized) reduced cost coefficients */
1919 /* for all variables in the constraint, modify the objective of the corresponding variable in a pricing problem */
1939 /* nothing to be done if variable belongs to redundant block or variable was directly transferred to the master
1940 * or variable is linking variable (which means, the directly transferred copy is part of the master cons)
1988 /* for all variables in the cut, modify the objective of the corresponding variable in a pricing problem */
2003 /* nothing to be done if variable belongs to redundant block or variable was directly transferred to the master
2004 * or variable is linking variable (which means, the directly transferred copy is part of the master cons)
2055 SCIP_VAR** solvars, /**< array of variables with non-zero value in the solution of the pricing problem */
2056 SCIP_Real* solvals, /**< array of values in the solution of the pricing problem for variables in array solvars*/
2060 SCIP_Bool force, /**< should the given variable be added also if it has non-negative reduced cost? */
2094 SCIPdebugMessage("var with redcost %g (objvalue=%g, dualsol=%g, ray=%u) was not added\n", redcost, objvalue, pricerdata->dualsolconv[prob], solisray);
2099 SCIPdebugMessage("found var with redcost %g (objvalue=%g, dualsol=%g, ray=%u)\n", redcost, objvalue, pricerdata->dualsolconv[prob], solisray);
2103 SCIPdebugMessage("force var (objvalue=%g, dualsol=%g, ray=%u)\n", objvalue, pricerdata->dualsolconv[prob], solisray);
2125 /* original variable is linking variable --> directly transferred master variable got the full obj,
2141 SCIPwarningMessage(scip, "variable with infinite objective value found in pricing, change objective to SCIPinfinity()/2\n");
2156 SCIP_CALL( GCGcreateMasterVar(scip, origprob, pricerdata->pricingprobs[prob], &newvar, varname, objcoeff,
2193 if( SCIPgetCurrentNode(scip) == SCIPgetRootNode(scip) && pricetype != NULL && pricetype->getType() == GCG_PRICETYPE_REDCOST )
2209 SCIP_Bool force, /**< should the given variable be added also if it has non-negative reduced cost? */
2252 SCIPdebugMessage(" var with redcost %g (dualsol=%g, ray=%u) was not added\n", redcost, pricerdata->dualsolconv[prob], isray);
2257 SCIPdebugMessage(" found var with redcost %g (dualsol=%g, ray=%u)\n", redcost, pricerdata->dualsolconv[prob], isray);
2284 /* original variable is linking variable --> directly transferred master variable got the full obj,
2296 SCIPwarningMessage(scip, "variable with infinite objective value found in pricing, change objective to SCIPinfinity()/2\n");
2311 SCIP_CALL( GCGcreateMasterVar(scip, GCGmasterGetOrigprob(scip), pricerdata->pricingprobs[prob], &newvar, varname, objcoeff,
2325 SCIP_CALL( SCIPaddPricedVar(scip, newvar, score /* pricerdata->dualsolconv[prob] - objvalue */ ) );
2350 if( SCIPgetCurrentNode(scip) == SCIPgetRootNode(scip) && pricetype->getType() == GCG_PRICETYPE_REDCOST )
2375 && SCIPisEQ(scip_, SCIPceil(scip_, SCIPgetNodeLowerbound(scip_, SCIPgetCurrentNode(scip_))), SCIPceil(scip_, SCIPgetLPObjval(scip_))) /* && SCIPgetNNodes(scip) > 1 ??????*/)
2377 GCGpricerPrintInfo(scip_, pricerdata, "pricing aborted due to integral objective: node LB = %g, LP obj = %g\n",
2386 gap = (SCIPgetLPObjval(scip_) - SCIPgetNodeLowerbound(scip_, SCIPgetCurrentNode(scip_)))/SCIPgetNodeLowerbound(scip_, SCIPgetCurrentNode(scip_));
2391 GCGpricerPrintInfo(scip_, pricerdata, "pricing aborted due to small gap: node LB = %g, LP obj = %g, gap = %g\n",
2445 SCIP_CALL( SCIPtightenVarLb(pricerdata->pricingprobs[prob], var, bound, TRUE, &infeasible, &tightened));
2447 assert(infeasible || tightened || SCIPisGE(pricerdata->pricingprobs[prob], SCIPvarGetLbGlobal(var), bound));
2451 SCIP_CALL( SCIPtightenVarUb(pricerdata->pricingprobs[prob], var, bound-1, TRUE, &infeasible, &tightened));
2453 assert(infeasible || tightened || SCIPisLE(pricerdata->pricingprobs[prob], SCIPvarGetUbGlobal(var), bound-1));
2526 /* SCIPdebugMessage("<%s> %.4f >= %.4f\n", SCIPvarGetName(pricingvar), val, components[i].bound); */
2531 /* SCIPdebugMessage("<%s> %.4f < %.4f\n", SCIPvarGetName(pricingvar), val, components[i].bound); */
2607 SCIP_CALL( GCGsolverSolve(scip_, pricingscip, solver, pricetype->getType() == GCG_PRICETYPE_REDCOST,
2680 SCIP_Bool* bestredcostvalid /**< pointer to store if bestredcost are valid (pp solvedoptimal) */
2734 // disable colpool while probing mode is active (can be removed after a feasibility check (#586) is implemented)
2743 && !GCGisBranchruleGeneric(GCGconsMasterbranchGetBranchrule(GCGconsMasterbranchGetActiveCons(scip_)));
2750 SCIP_CALL( SCIPgetBoolParam(GCGmasterGetOrigprob(scip_), "sepa/basis/enableppcuts", &enableppcuts) );
2802 SCIPstatisticMessage("MLP t: %g\n", SCIPgetClockTime(scip_, scip_->stat->primallptime) + SCIPgetClockTime(scip_, scip_->stat->duallptime));
2806 SCIPdebugMessage("***** New pricing round at node %" SCIP_LONGINT_FORMAT " (depth = %d), maxniters = %d\n",
2821 *bestredcostvalid = isMasterLPOptimal() && !GCGisBranchruleGeneric(GCGconsMasterbranchGetBranchrule(GCGconsMasterbranchGetActiveCons(scip_)));
2826 SCIPdebugMessage("****************************** Mispricing iteration ******************************\n");
2856 SCIP_CALL( GCGsolverUpdate(pricerdata->pricingprobs[j], pricerdata->solvers[i], j, TRUE, TRUE, FALSE) );
2892 /* actual pricing loop: perform the pricing jobs until none are left or an abortion criterion is met */
2893 #pragma omp parallel for ordered firstprivate(pricingjob) shared(retcode, pricetype, nfoundvars, nsuccessfulprobs) schedule(static,1)
2916 if( (pricingcontroller->canPricingloopBeAborted(pricetype, nfoundvars, nsuccessfulprobs) || infeasible) && !stabilized )
2918 SCIPdebugMessage("*** Abort pricing loop, infeasible = %u, stabilized = %u\n", infeasible, stabilized);
2928 GCGpricingprobGetProbnr(pricingprob), GCGsolverGetName(GCGpricingjobGetSolver(pricingjob)), stabilized,
2953 pricingcontroller->updatePricingprob(pricingprob, status, problowerbound, GCGpricestoreGetNEfficaciousCols(pricestore) - oldnimpcols);
2975 GCGpricingprobGetProbnr(pricingprob), GCGpricestoreGetNEfficaciousCols(pricestore) - oldnimpcols, pricingtime);
2990 pricingcontroller->collectResults(bestcols, &infeasible, &optimal, bestobjvals, &beststabobj, &bestredcost, bestredcostvalid);
2995 SCIPdebugMessage("optimal = %u, bestredcostvalid = %u, stabilized = %u\n", optimal, *bestredcostvalid, stabilized);
3009 SCIPdebugMessage("lpobjval = %.8g, bestredcost = %.8g, stabdualval = %.8g, beststabobj = %.8g\n",
3013 assert(!optimal || !*bestredcostvalid || stabilized || SCIPisDualfeasEQ(scip_, SCIPgetLPObjval(scip_) + bestredcost, lowerboundcandidate));
3021 /* If all pricing problems have been solved to optimality, update subgradient product and stability center */
3031 /* activate or deactivate mispricing schedule, depending on whether improving columns have been found */
3058 SCIP_CALL( SCIPgetBoolParam(GCGmasterGetOrigprob(scip_), "sepa/basis/enableppobjcg", &enableppobjcg) );
3084 SCIP_CALL( GCGpricestoreApplyCols(pricestore, colpool, (pricerdata->usecolpool && !probingnode), &nfoundvars) );
3092 SCIP_CALL( SCIPgetBoolParam(GCGmasterGetOrigprob(scip_), "sepa/basis/enableppcuts", &enableppcuts) );
3121 SCIPstatisticMessage("MLP t: %g\n", SCIPgetClockTime(scip_, scip_->stat->primallptime) + SCIPgetClockTime(scip_, scip_->stat->duallptime));
3142 SCIP_CALL( computeDualDiff(olddualvalues, olddualconv, pricerdata->realdualvalues, pricerdata->dualsolconv, &dualdiff) );
3196 SCIP_CALL( GCGsolverUpdate(pricer->pricerdata->pricingprobs[j], pricer->pricerdata->solvers[i], j, TRUE, FALSE, FALSE) );
3219 SCIP_Bool force, /**< should the given variable be added also if it has non-negative reduced cost? */
3239 SCIP_CALL( pricer->createNewMasterVarFromGcgCol(scip, pricetype, gcgcol, force, added, addedvar, score) );
3292 /** performs the pricing routine, gets the type of pricing that should be done: farkas or redcost pricing */
3309 GCGpricerPrintInfo(scip_, pricerdata, "nvars = %d, current LP objval = %g, time = %f, node = %lld\n",
3334 /* If pricing is performed for the first time at this node, update variable bounds and pricing constraints */
3346 SCIP_CALL( GCGsolverUpdate(pricerdata->pricingprobs[j], pricerdata->solvers[i], j, FALSE, TRUE, TRUE) );
3365 SCIPdebugMessage("%s pricing: found %d new vars\n", (pricetype->getType() == GCG_PRICETYPE_REDCOST ? "Redcost" : "Farkas"), nfoundvars);
3367 if( GCGisRootNode(scip_) && pricetype->getType() == GCG_PRICETYPE_REDCOST && pricetype->getCalls() > 0 )
3385 pricerdata->avgrootnodedegeneracy -= (pricerdata->avgrootnodedegeneracy/(pricerdata->ndegeneracycalcs) - degeneracy/(pricerdata->ndegeneracycalcs));
3407 ) : ObjPricer(scip, name, desc, priority, delay), colpool(NULL), pricestore(NULL), reducedcostpricing(NULL), farkaspricing(NULL), pricingcontroller(NULL), stabilization(NULL)
3468 /** solving process initialization method of variable pricer (called when branch and bound process is about to begin) */
3501 SCIP_CALL( SCIPallocBlockMemoryArray(scip, &(pricerdata->pricingprobs), pricerdata->npricingprobs) );
3502 SCIP_CALL( SCIPallocBlockMemoryArray(scip, &(pricerdata->npointsprob), pricerdata->npricingprobs) );
3503 SCIP_CALL( SCIPallocBlockMemoryArray(scip, &(pricerdata->nraysprob), pricerdata->npricingprobs) );
3505 SCIP_CALL( SCIPallocBlockMemoryArray(scip, &(pricerdata->farkascallsdist), pricerdata->npricingprobs) );
3506 SCIP_CALL( SCIPallocBlockMemoryArray(scip, &(pricerdata->farkasfoundvars), pricerdata->npricingprobs) );
3507 SCIP_CALL( SCIPallocBlockMemoryArray(scip, &(pricerdata->farkasnodetimedist), pricerdata->npricingprobs) );
3509 SCIP_CALL( SCIPallocBlockMemoryArray(scip, &(pricerdata->redcostcallsdist), pricerdata->npricingprobs) );
3510 SCIP_CALL( SCIPallocBlockMemoryArray(scip, &(pricerdata->redcostfoundvars), pricerdata->npricingprobs) );
3511 SCIP_CALL( SCIPallocBlockMemoryArray(scip, &(pricerdata->redcostnodetimedist), pricerdata->npricingprobs) );
3537 pricerdata->maxrealdualvalues[i] = SCIPcalcMemGrowSize(scip, SCIPgetNVars(pricerdata->pricingprobs[i]));
3538 SCIP_CALL( SCIPallocBlockMemoryArray(scip, &(pricerdata->realdualvalues[i]), pricerdata->maxrealdualvalues[i]) ); /*lint !e666 !e866*/
3550 SCIP_CALL( SCIPallocBlockMemoryArray(scip, &(pricerdata->dualsolconv), pricerdata->npricingprobs) );
3576 SCIP_CALL( SCIPhashmapCreate(&(pricerdata->mapcons2idx), SCIPblkmem(scip), 10 * nmasterconss +1) );
3580 assert((int)(size_t)SCIPhashmapGetImage(pricerdata->mapcons2idx, masterconss[i]) == i); /*lint !e507*/
3585 SCIP_CALL( SCIPallocBlockMemoryArray(scip, &pricerdata->pricedvars, pricerdata->maxpricedvars) );
3597 SCIP_CALL( SCIPallocBlockMemoryArray(scip, &pricerdata->roottimes, pricerdata->maxrootbounds) );
3598 SCIP_CALL( SCIPallocBlockMemoryArray(scip, &pricerdata->rootdualdiffs, pricerdata->maxrootbounds) );
3599 SCIP_CALL( SCIPallocBlockMemoryArray(scip, &pricerdata->dualvalues, pricerdata->maxrootbounds) );
3600 SCIP_CALL( SCIPallocBlockMemoryArray(scip, &pricerdata->dualsolconvs, pricerdata->maxrootbounds) );
3601 SCIP_CALL( SCIPallocMemoryArray(scip, &(pricerdata->nodetimehist), PRICER_STAT_ARRAYLEN_TIME) ); /*lint !e506*/
3602 SCIP_CALL( SCIPallocMemoryArray(scip, &(pricerdata->foundvarshist), PRICER_STAT_ARRAYLEN_VARS) ); /*lint !e506*/
3653 SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL, "Big M to be used for artificial variables not reliable; use regular Farkas pricing instead.\n");
3656 SCIPwarningMessage(scip, "Big M used for artificial variables not reliable. This might lead to wrong solutions.\n");
3676 /** solving process deinitialization method of variable pricer (called before branch and bound process data is freed) */
3725 SCIPfreeBlockMemoryArrayNull(scip, &(pricerdata->artificialvars), pricerdata->maxartificialvars);
3764 SCIPfreeBlockMemoryArrayNull(scip, &(pricerdata->realdualvalues[i]), pricerdata->maxrealdualvalues[i]);
3766 SCIPfreeBlockMemoryArray(scip, &(pricerdata->realdualvalues), pricerdata->maxrealdualvaluescapacity);
3767 SCIPfreeBlockMemoryArray(scip, &(pricerdata->maxrealdualvalues), pricerdata->maxrealdualvaluescapacity);
3801 if( SCIPgetCurrentNode(scip) == SCIPgetRootNode(scip) && GCGsepaGetNCuts(scip) == 0 && reducedcostpricing->getCalls() > 0
3804 SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL, "Starting reduced cost pricing without artificial variables...\n");
3825 /* if the number of reduced cost pricing rounds at the current node exceeds the limit (and we are not at the root), stop pricing;
3828 if( reducedcostpricing->getMaxrounds() == 0 || (pricerdata->nroundsredcost >= reducedcostpricing->getMaxrounds() && pricerdata->currnodenr != 1) )
3869 SCIP_CALL( SCIPreallocBlockMemoryArray(scip_, &(pricerdata->artificialvars), oldsize, pricerdata->maxartificialvars) );
3907 SCIP_CALL( GCGcreateArtificialVar(scip_, &(pricerdata->artificialvars[pricerdata->nartificialvars]), varname, bigm) );
3908 SCIP_CALL( SCIPaddCoefLinear(scip_, masterconss[i], pricerdata->artificialvars[pricerdata->nartificialvars], 1.0) );
3917 SCIP_CALL( GCGcreateArtificialVar(scip_, &(pricerdata->artificialvars[pricerdata->nartificialvars]), varname, bigm) );
3918 SCIP_CALL( SCIPaddCoefLinear(scip_, masterconss[i], pricerdata->artificialvars[pricerdata->nartificialvars], -1.0) );
3937 SCIP_CALL( GCGcreateArtificialVar(scip_, &(pricerdata->artificialvars[pricerdata->nartificialvars]), varname, bigm) );
3938 SCIP_CALL( SCIPaddCoefLinear(scip_, convcons, pricerdata->artificialvars[pricerdata->nartificialvars], 1.0) );
3947 SCIP_CALL( GCGcreateArtificialVar(scip_, &(pricerdata->artificialvars[pricerdata->nartificialvars]), varname, bigm) );
3948 SCIP_CALL( SCIPaddCoefLinear(scip_, convcons, pricerdata->artificialvars[pricerdata->nartificialvars], -1.0) );
4008 SCIPsolGetHeur(origsols[i]) == NULL ? "relaxation" : SCIPheurGetName(SCIPsolGetHeur(origsols[i])));
4015 SCIPdebugMessage("GCGmasterTransOrigSolToMasterVars() transferred %d original feasible solutions\n",
4030 SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL, "Add artificial variables ensuring the restricted master problem is feasible.\n");
4080 (GCGgetNPricingprobs(origprob) == GCGgetNRelPricingprobs(origprob) && pricerdata->hybridascentnoagg);
4132 pricer = new ObjPricerGcg(scip, origprob, PRICER_NAME, PRICER_DESC, PRICER_PRIORITY, PRICER_DELAY, pricerdata);
4160 "how many threads should be used to concurrently solve the pricing problem (0 to guess threads by OpenMP)",
4172 "should the colpool be checked for negative redcost cols before solving the pricing problems?",
4180 "should hybridization of smoothing with an ascent method be enabled if pricing problems cannot be aggregation?",
4184 "should artificial variables be used to make the RMP feasible (instead of applying Farkas pricing)?",
4197 &pricerdata->factorunreliable, FALSE, DEFAULT_FACTORUNRELIABLE, 0.0, SCIPinfinity(origprob), NULL, NULL) );
4201 &pricerdata->bigmartificial, FALSE, DEFAULT_BIGMARTIFICIAL, 0.0, SCIPinfinity(origprob), NULL, NULL) );
4207 &pricerdata->disablecutoff, FALSE, DEFAULT_DISABLECUTOFF, 0, 2, paramChgdDisablecutoff, NULL) );
4318 SCIPdebugMessage("Added cons %s (%p) to hashmap with index %d\n", SCIPconsGetName(cons), (void*) cons, pos);
4375 SCIP_Bool heurenabled, /**< flag to indicate whether heuristic solving method of the solver is enabled */
4376 SCIP_Bool exactenabled, /**< flag to indicate whether exact solving method of the solver is enabled */
4403 solverupdate, solversolve, solversolveheur, solverfree, solverinit, solverexit, solverinitsol, solverexitsol,
4414 SCIP_CALL( SCIPreallocMemoryArray(scip_, &(pricerdata->solvers), (size_t)pricerdata->nsolvers+1) );
4492 SCIPdialogMessage(scip, NULL, " %5s", GCGsolverIsHeurEnabled(pricerdata->solvers[i]) ? "TRUE" : "FALSE");
4493 SCIPdialogMessage(scip, NULL, " %5s", GCGsolverIsExactEnabled(pricerdata->solvers[i]) ? "TRUE" : "FALSE");
4518 "Pricing Solver : #HeurFarkas #OptFarkas #HeurRedcost #OptRedcost Time: HeurFarkas OptFarkas HeurRedcost OptRedcost\n");
4567 SCIPmessageFPrintInfo(SCIPgetMessagehdlr(scip), file, "Farkas pricing Statistic:\nno.\t#Calls\t\t#Vars\t\ttime(s)\n");
4571 SCIPmessageFPrintInfo(SCIPgetMessagehdlr(scip), file, "%d \t %d \t\t %d \t\t %.2f \n", i, pricerdata->farkascallsdist[i],
4576 SCIPmessageFPrintInfo(SCIPgetMessagehdlr(scip), file, "Reduced Cost pricing Statistic:\nno.\t#Calls\t\t#Vars\t\ttime(s)\n");
4580 SCIPmessageFPrintInfo(SCIPgetMessagehdlr(scip), file, "%d \t %d \t\t %d \t\t %.2f \n", i, pricerdata->redcostcallsdist[i],
4595 SCIPmessageFPrintInfo(SCIPgetMessagehdlr(scip), file, "From\t%.4f\t-\t%.4f\ts:\t\t%d \n", start, end, pricerdata->nodetimehist[i]);
4606 SCIPmessageFPrintInfo(SCIPgetMessagehdlr(scip), file, "From\t%.0f\t-\t%.0f\tvars:\t\t%d \n", start, end, pricerdata->foundvarshist[i]);
4610 SCIPmessageFPrintInfo(SCIPgetMessagehdlr(scip), file, " iter pb db time dualdiff dualoptdiff\n");
4624 pricer->computeDualDiff(pricerdata->dualvalues[i], pricerdata->dualsolconvs[i], pricerdata->dualvalues[pricerdata->nrootbounds - 1], pricerdata->dualsolconvs[pricerdata->nrootbounds - 1], &dualoptdiff);
4626 SCIPmessageFPrintInfo(SCIPgetMessagehdlr(scip), file, "%5d %13.6e %13.6e %15.5f %15.5f %15.5f\n", i, pb, db, time, dualdiff, dualoptdiff);
4637 SCIPmessageFPrintInfo(SCIPgetMessagehdlr(scip), file, "Farkas Pricing Calls : %d\n", farkas->getCalls());
4638 SCIPmessageFPrintInfo(SCIPgetMessagehdlr(scip), file, "Farkas Pricing Time : %f\n", farkas->getClockTime());
4639 SCIPmessageFPrintInfo(SCIPgetMessagehdlr(scip), file, "Reduced Cost Pricing Calls : %d\n", redcost->getCalls());
4640 SCIPmessageFPrintInfo(SCIPgetMessagehdlr(scip), file, "Reduced Cost Pricing Time : %f\n", redcost->getClockTime());
4641 SCIPmessageFPrintInfo(SCIPgetMessagehdlr(scip), file, "Solved subMIPs Heuristic Pricing : %d\n", pricerdata->solvedsubmipsheur);
4642 SCIPmessageFPrintInfo(SCIPgetMessagehdlr(scip), file, "Solved subMIPs Optimal Pricing : %d\n", pricerdata->solvedsubmipsoptimal);
4643 SCIPmessageFPrintInfo(SCIPgetMessagehdlr(scip), file, "Time for transformation : %f\n", SCIPgetClockTime(scip, pricerdata->transformclock));
4644 SCIPmessageFPrintInfo(SCIPgetMessagehdlr(scip), file, "Time for freeing subMIPs : %f\n", SCIPgetClockTime(scip, pricerdata->freeclock));
4746 /** get the number of columns per pricing problem to be added to the master LP in the current pricing round */
4780 * i.e. creates one master variable for each block and adds the solution to the master problem */
4823 pricerdata = NULL; /* the pricerdata is set to NULL when the Benders' decomposition mode is used. */
4842 SCIP_CALL( SCIPallocBufferArray(scip, &pricingvars, pricerdata->npricingprobs) ); /*lint !e530*/
4843 SCIP_CALL( SCIPallocBufferArray(scip, &pricingvals, pricerdata->npricingprobs) ); /*lint !e530*/
4844 SCIP_CALL( SCIPallocBufferArray(scip, &npricingvars, pricerdata->npricingprobs) ); /*lint !e530*/
4852 SCIP_CALL( SCIPallocBufferArray(scip, &(pricingvars[i]), SCIPgetNVars(pricerdata->pricingprobs[representative])) ); /*lint !e866*/
4853 SCIP_CALL( SCIPallocBufferArray(scip, &(pricingvals[i]), SCIPgetNVars(pricerdata->pricingprobs[representative])) ); /*lint !e866*/
4882 assert((GCGoriginalVarGetNMastervars(origvars[i]) == 1) || (GCGoriginalVarIsLinking(origvars[i])));
4942 SCIP_CALL( pricer->createNewMasterVar(scip, NULL, NULL, pricingvars[prob], pricingvals[prob], npricingvars[prob], FALSE, representative, TRUE, &added, &newvar) );
5080 if( SCIPgetStage(scip) >= SCIP_STAGE_INITPRESOLVE && SCIPgetStage(scip) <= SCIP_STAGE_SOLVING && GCGisRootNode(scip) )
5101 /* checking the decomposition mode. If Benders' is used, then the solution is assumed to be valid. */
5145 /* checking the decomposition mode. If Benders' is used, then the solution is assumed to be valid. */
5184 /* checking the decomposition mode. If Benders' is used, then the solution is assumed to be valid. */
5248 SCIPmessageFPrintInfo(SCIPgetMessagehdlr(scip), file, " Master LP : %10lld\n", SCIPgetNLPIterations(scip));
5254 SCIPmessageFPrintInfo(SCIPgetMessagehdlr(scip), file, " Pricing LP : %10lld\n", pricerdata->pricingiters);
5258 SCIPmessageFPrintInfo(SCIPgetMessagehdlr(scip), file, " Original LP : %10lld\n", SCIPgetNLPIterations(pricer->getOrigprob()));
SCIP_EXPORT SCIP_Real GCGsolverGetHeurRedcostTime(SCIP *scip, GCG_SOLVER *solver)
Definition: solver.c:524
int GCGgetBlockRepresentative(SCIP *scip, int pricingprobnr)
Definition: relax_gcg.c:4023
SCIP_RETCODE GCGsolverCreate(SCIP *scip, GCG_SOLVER **solver, const char *name, const char *desc, int priority, SCIP_Bool heurenabled, SCIP_Bool exactenabled, GCG_DECL_SOLVERUPDATE((*solverupdate)), GCG_DECL_SOLVERSOLVE((*solversolve)), GCG_DECL_SOLVERSOLVEHEUR((*solveheur)), GCG_DECL_SOLVERFREE((*solverfree)), GCG_DECL_SOLVERINIT((*solverinit)), GCG_DECL_SOLVEREXIT((*solverexit)), GCG_DECL_SOLVERINITSOL((*solverinitsol)), GCG_DECL_SOLVEREXITSOL((*solverexitsol)), GCG_SOLVERDATA *solverdata)
Definition: solver.c:59
SCIP_RETCODE priceNewVariables(PricingType *pricetype, SCIP_RESULT *result, double *lowerbound)
Definition: pricer_gcg.cpp:3293
public methods for GCG pricing solvers
public methods for working with pricing problems
SCIP_RETCODE addParameters()
Definition: class_pricingcontroller.cpp:110
class with functions for dual variable smoothing
GCG interface methods.
SCIP_RETCODE pricingLoop(PricingType *pricetype, SCIP_RESULT *result, int *nfoundvars, SCIP_Real *lowerbound, SCIP_Bool *bestredcostvalid)
Definition: pricer_gcg.cpp:2675
void GCGpricestoreStartFarkas(GCG_PRICESTORE *pricestore)
Definition: pricestore_gcg.c:152
SCIP_RETCODE computeDualDiff(SCIP_Real **dualvals1, SCIP_Real *dualconv1, SCIP_Real **dualvals2, SCIP_Real *dualconv2, SCIP_Real *dualdiff)
Definition: pricer_gcg.cpp:2641
SCIP_EXPORT int GCGsolverGetHeurRedcostCalls(GCG_SOLVER *solver)
Definition: solver.c:478
SCIP_EXPORT int GCGsolverGetOptFarkasCalls(GCG_SOLVER *solver)
Definition: solver.c:448
void GCGcolUpdateRedcost(GCG_COL *gcgcol, SCIP_Real redcost, SCIP_Bool growold)
Definition: gcgcol.c:375
void GCGpricingprobMarkBranchconsAdded(GCG_PRICINGPROB *pricingprob)
Definition: pricingprob.c:252
int GCGpricingprobGetBranchconsIdx(GCG_PRICINGPROB *pricingprob)
Definition: pricingprob.c:236
SCIP_Longint GCGmasterGetPricingSimplexIters(SCIP *scip)
Definition: pricer_gcg.cpp:5209
Definition: pricer_gcg.cpp:145
int GCGpricestoreGetNCols(GCG_PRICESTORE *pricestore)
Definition: pricestore_gcg.c:719
SCIP_Real getConvconsDualsol(PricingType *pricetype, int probnr)
Definition: pricer_gcg.cpp:690
Definition: struct_gcgcol.h:50
SCIP_RETCODE createNewMasterVar(SCIP *scip, PricingType *pricetype, SCIP_SOL *sol, SCIP_VAR **solvars, double *solvals, int nsolvars, unsigned int solisray, int prob, unsigned int force, unsigned int *added, SCIP_VAR **addedvar)
Definition: pricer_gcg.cpp:2051
GCG_BRANCHDATA * GCGconsMasterbranchGetBranchdata(SCIP_CONS *cons)
Definition: cons_masterbranch.c:2498
SCIP_VAR ** GCGoriginalVarGetMastervars(SCIP_VAR *var)
Definition: gcgvar.c:587
SCIP_Bool GCGmasterIsSolValid(SCIP *scip, SCIP_SOL *mastersol)
Definition: pricer_gcg.cpp:5173
Definition: class_stabilization.h:44
eventhdlr to disable the master display after the root node
SCIP_RETCODE GCGsolverSolve(SCIP *scip, SCIP *pricingprob, GCG_SOLVER *solver, SCIP_Bool redcost, SCIP_Bool heuristic, int probnr, SCIP_Real dualsolconv, SCIP_Real *lowerbound, GCG_PRICINGSTATUS *status, SCIP_Bool *solved)
Definition: solver.c:280
int GCGbranchGenericBranchdataGetConsSsize(GCG_BRANCHDATA *branchdata)
Definition: branch_generic.c:3018
SCIP_Real GCGcolGetSolVal(SCIP *scip, GCG_COL *gcgcol, SCIP_VAR *var)
Definition: gcgcol.c:613
SCIP_RETCODE createPricingcontroller()
Definition: pricer_gcg.cpp:4066
SCIP_EXPORT SCIP_Real GCGsolverGetOptFarkasTime(SCIP *scip, GCG_SOLVER *solver)
Definition: solver.c:488
public methods for working with pricing jobs
SCIP_DECL_PRICERINITSOL(ObjPricerGcg::scip_initsol)
Definition: pricer_gcg.cpp:3469
SCIP_EXPORT SCIP_Real GCGsolverGetHeurFarkasTime(SCIP *scip, GCG_SOLVER *solver)
Definition: solver.c:512
SCIP_RETCODE GCGconsMasterbranchAddRootCons(SCIP *scip)
Definition: cons_masterbranch.c:2696
GCG_SOLVER * GCGpricingjobGetSolver(GCG_PRICINGJOB *pricingjob)
Definition: pricingjob.c:133
SCIP_RETCODE GCGconsGetVars(SCIP *scip, SCIP_CONS *cons, SCIP_VAR **vars, int nvars)
Definition: scip_misc.c:490
int GCGpricerGetNPointsProb(SCIP *scip, int probnr)
Definition: pricer_gcg.cpp:4684
SCIP_RETCODE GCGmasterSetRootLPSol(SCIP *scip, SCIP_SOL **sol)
Definition: branch_generic.h:52
SCIP_RETCODE createNewMasterVarFromGcgCol(SCIP *scip, PricingType *pricetype, GCG_COL *gcgcol, SCIP_Bool force, SCIP_Bool *added, SCIP_VAR **addedvar, SCIP_Real score)
Definition: pricer_gcg.cpp:2205
SCIP_EXPORT int GCGsolverGetOptRedcostCalls(GCG_SOLVER *solver)
Definition: solver.c:458
public methods for working with gcg columns
virtual SCIP_Real rowGetDual(SCIP_ROW *row) const =0
SCIP_RETCODE GCGcolpoolUpdateRedcost(GCG_COLPOOL *colpool)
Definition: colpool.c:451
SCIP * GCGgetPricingprob(SCIP *scip, int pricingprobnr)
Definition: relax_gcg.c:3939
FarkasPricing * getFarkasPricingNonConst()
Definition: objpricer_gcg.h:177
void GCGpricerPrintListOfSolvers(SCIP *scip)
Definition: pricer_gcg.cpp:4464
SCIP_RETCODE GCGpricestoreFree(SCIP *scip, GCG_PRICESTORE **pricestore)
Definition: pricestore_gcg.c:127
SCIP_VAR * GCGoriginalVarGetPricingVar(SCIP_VAR *var)
Definition: gcgvar.c:216
void updateRedcosts(PricingType *pricetype, GCG_COL **cols, int ncols, int *nimpcols)
SCIP_Bool GCGcolGetInitializedCoefs(GCG_COL *gcgcol)
Definition: gcgcol.c:512
SCIP_EXPORT int GCGsolverGetHeurFarkasCalls(GCG_SOLVER *solver)
Definition: solver.c:468
SCIP_RETCODE GCGcreateArtificialVar(SCIP *scip, SCIP_VAR **newvar, const char *name, SCIP_Real objcoef)
Definition: gcgvar.c:1522
GCG variable pricer.
GCG variable pricer.
various SCIP helper methods
SCIP_EXPORT int GCGsolverGetPriority(GCG_SOLVER *solver)
Definition: solver.c:418
SCIP_Real GCGgetPricingprobsMemUsed(SCIP *scip)
Definition: relax_gcg.c:4925
ReducedCostPricing * getReducedCostPricingNonConst()
Definition: objpricer_gcg.h:187
virtual SCIP_Real varGetObj(SCIP_VAR *var) const =0
SCIP_CONS ** GCGlinkingVarGetLinkingConss(SCIP_VAR *var)
Definition: gcgvar.c:787
Definition: solver_cliquer.c:59
GCG_PRICINGPROB * GCGpricingjobGetPricingprob(GCG_PRICINGJOB *pricingjob)
Definition: pricingjob.c:126
SCIP_Real computeRedCostGcgCol(PricingType *pricetype, GCG_Col *gcgcol, SCIP_Real *objvalptr) const
Definition: pricer_gcg.cpp:1566
SCIP_DECL_PRICERREDCOST(ObjPricerGcg::scip_redcost)
Definition: pricer_gcg.cpp:3774
SCIP_RETCODE computeColMastercuts(GCG_COL *gcgcol)
Definition: pricer_gcg.cpp:1330
SCIP_RETCODE computeColMastercoefs(GCG_COL *gcgcol)
Definition: pricer_gcg.cpp:1113
int maxrealdualvaluescapacity
Definition: pricer_gcg.cpp:170
SCIP_RETCODE GCGpricestoreApplyCols(GCG_PRICESTORE *pricestore, GCG_COLPOOL *colpool, SCIP_Bool usecolpool, int *nfoundvars)
Definition: pricestore_gcg.c:523
virtual SCIP_RETCODE addParameters()
Definition: class_pricingtype.cpp:168
SCIP_BRANCHRULE * GCGconsMasterbranchGetBranchrule(SCIP_CONS *cons)
Definition: cons_masterbranch.c:2511
ObjPricerGcg(SCIP *scip, SCIP *origscip, const char *name, const char *desc, int priority, unsigned int delay, SCIP_PRICERDATA *pricerdata)
Definition: pricer_gcg.cpp:3399
constraint handler for storing the branching decisions at each node of the tree
int GCGpricerGetNRaysProb(SCIP *scip, int probnr)
Definition: pricer_gcg.cpp:4708
void GCGsetRootRedcostCall(SCIP_VAR *var, SCIP_Longint rootredcostcall)
Definition: gcgvar.c:1647
SCIP_RETCODE GCGsolverExitsol(SCIP *scip, GCG_SOLVER *solver)
Definition: solver.c:240
master separator
Definition: struct_pricingprob.h:52
SCIP_RETCODE GCGoriginalVarAddMasterVar(SCIP *scip, SCIP_VAR *origvar, SCIP_VAR *var, SCIP_Real val)
Definition: gcgvar.c:1121
virtual SCIP_RETCODE addParameters()
Definition: class_pricingtype.cpp:242
branching rule based on vanderbeck's generic branching scheme
SCIP_RETCODE GCGmasterAddMasterconsToHashmap(SCIP *scip, SCIP_CONS *cons, int pos)
Definition: pricer_gcg.cpp:4296
basis separator
public methods for storing cols in a col pool
SCIP_RETCODE GCGcreateInitialMasterVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **newvar)
Definition: gcgvar.c:1472
pricing controller managing the pricing strategy
DEC_DECMODE GCGgetMasterDecompMode(SCIP *masterprob)
Definition: relax_gcg.c:5144
int GCGgetNIdenticalBlocks(SCIP *scip, int pricingprobnr)
Definition: relax_gcg.c:4053
SCIP_RETCODE GCGcolSetLinkvars(GCG_COL *gcgcol, int *linkvars, int nlinkvars)
Definition: gcgcol.c:536
SCIP_EXPORT SCIP_Bool GCGsolverIsExactEnabled(GCG_SOLVER *solver)
Definition: solver.c:438
Definition: struct_pricingjob.h:52
SCIP_RETCODE GCGoriginalVarRemoveMasterVar(SCIP *scip, SCIP_VAR *origvar, SCIP_VAR *var)
Definition: gcgvar.c:1168
Definition: class_pricingtype.h:41
SCIP_RETCODE GCGcreateMasterVar(SCIP *scip, SCIP *origscip, SCIP *pricingscip, SCIP_VAR **newvar, const char *varname, SCIP_Real objcoeff, SCIP_VARTYPE vartype, SCIP_Bool solisray, int prob, int nsolvars, SCIP_Real *solvals, SCIP_VAR **solvars, SCIP_Bool auxiliaryvar)
Definition: gcgvar.c:1309
SCIP * GCGpricingprobGetPricingscip(GCG_PRICINGPROB *pricingprob)
Definition: pricingprob.c:196
SCIP_RETCODE GCGpricestoreAddCol(SCIP *scip, GCG_PRICESTORE *pricestore, GCG_COL *col, SCIP_Bool forcecol)
Definition: pricestore_gcg.c:243
SCIP_CONS ** GCGoriginalVarGetMasterconss(SCIP_VAR *var)
Definition: gcgvar.c:710
SCIP_RETCODE GCGmasterTransOrigSolToMasterVars(SCIP *scip, SCIP_SOL *origsol, SCIP_Bool *stored)
Definition: pricer_gcg.cpp:4782
SCIP_RETCODE GCGpricerIncludeSolver(SCIP *scip, const char *name, const char *desc, int priority, SCIP_Bool heurenabled, SCIP_Bool exactenabled, GCG_DECL_SOLVERUPDATE((*solverupdate)), GCG_DECL_SOLVERSOLVE((*solversolve)), GCG_DECL_SOLVERSOLVEHEUR((*solversolveheur)), GCG_DECL_SOLVERFREE((*solverfree)), GCG_DECL_SOLVERINIT((*solverinit)), GCG_DECL_SOLVEREXIT((*solverexit)), GCG_DECL_SOLVERINITSOL((*solverinitsol)), GCG_DECL_SOLVEREXITSOL((*solverexitsol)), GCG_SOLVERDATA *solverdata)
Definition: pricer_gcg.cpp:4370
SCIP_RETCODE getStabilizedDualObjectiveValue(PricingType *pricetype, SCIP_Real *stabdualval, SCIP_Bool stabilize)
Definition: pricer_gcg.cpp:1717
SCIP_RETCODE GCGpricerExistRays(SCIP *scip, SCIP_Bool *exist)
Definition: pricer_gcg.cpp:4650
GCG_COMPSEQUENCE * GCGbranchGenericBranchdataGetConsS(GCG_BRANCHDATA *branchdata)
Definition: branch_generic.c:3009
Definition: struct_solver.h:46
SCIP_RETCODE GCGconsGetVals(SCIP *scip, SCIP_CONS *cons, SCIP_Real *vals, int nvals)
Definition: scip_misc.c:621
void GCGpricerPrintPricingStatistics(SCIP *scip, FILE *file)
Definition: pricer_gcg.cpp:4500
void GCGpricerPrintStatistics(SCIP *scip, FILE *file)
Definition: pricer_gcg.cpp:4540
SCIP_RETCODE GCGcolSetMastercoefs(GCG_COL *gcgcol, SCIP_Real *mastercoefs, int nmastercoefs)
Definition: gcgcol.c:409
SCIP_Bool GCGisBranchruleGeneric(SCIP_BRANCHRULE *branchrule)
Definition: branch_generic.c:3045
GCG relaxator.
SCIP_CONS * GCGconsMasterbranchGetActiveCons(SCIP *scip)
Definition: cons_masterbranch.c:2628
virtual SCIP_Real consGetDual(SCIP *scip, SCIP_CONS *cons) const =0
SCIP_VAR ** GCGpricingVarGetOrigvars(SCIP_VAR *var)
Definition: gcgvar.c:1015
SCIP_RETCODE GCGpricestoreCreate(SCIP *scip, GCG_PRICESTORE **pricestore, SCIP_Real efficiacyfac, SCIP_Real objparalfac, SCIP_Real orthofac, SCIP_Real mincolorth, GCG_EFFICIACYCHOICE efficiacychoice)
Definition: pricestore_gcg.c:85
virtual SCIP_Real getClockTime() const
Definition: class_pricingtype.cpp:115
GCG_COL ** GCGpricestoreGetCols(GCG_PRICESTORE *pricestore)
Definition: pricestore_gcg.c:709
const SCIP_EXPORT char * GCGsolverGetName(GCG_SOLVER *solver)
Definition: solver.c:398
SCIP_RETCODE GCGsepaBasisAddPricingCut(SCIP *scip, int ppnumber, SCIP_ROW *cut)
Definition: sepa_basis.c:1759
SCIP_Bool GCGpricingjobIsHeuristic(GCG_PRICINGJOB *pricingjob)
Definition: pricingjob.c:222
Definition: objpricer_gcg.h:55
SCIP_RETCODE GCGsolverUpdate(SCIP *pricingprob, GCG_SOLVER *solver, int probnr, SCIP_Bool varobjschanged, SCIP_Bool varbndschanged, SCIP_Bool consschanged)
Definition: solver.c:257
SCIP_RETCODE GCGsolverInitsol(SCIP *scip, GCG_SOLVER *solver)
Definition: solver.c:223
Definition: branch_bpstrong.c:109
SCIP_Bool GCGmasterIsCurrentSolValid(SCIP *scip)
Definition: pricer_gcg.cpp:5090
const SCIP_EXPORT char * GCGsolverGetDesc(GCG_SOLVER *solver)
Definition: solver.c:408
SCIP_RETCODE GCGcolpoolFree(SCIP *scip, GCG_COLPOOL **colpool)
Definition: colpool.c:195
void GCGpricingprobGetGenericBranchData(GCG_PRICINGPROB *pricingprob, SCIP_CONS ***branchconss, SCIP_Real **branchduals, int *nbranchconss)
Definition: pricingprob.c:212
SCIP_DECL_PRICERFARKAS(ObjPricerGcg::scip_farkas)
Definition: pricer_gcg.cpp:3961
SCIP_RETCODE addColToPricestore(GCG_COL *col)
Definition: pricer_gcg.cpp:1647
SCIP_RETCODE GCGmasterCreateInitialMastervars(SCIP *scip)
Definition: pricer_gcg.cpp:4980
SCIP_RETCODE GCGcolpoolUpdateNode(GCG_COLPOOL *colpool)
Definition: colpool.c:429
const ReducedCostPricing * getReducedCostPricing() const
Definition: objpricer_gcg.h:182
SCIP_Real GCGcomputeRedCostGcgCol(SCIP *scip, SCIP_Bool infarkas, GCG_COL *gcgcol, SCIP_Real *objvalptr)
Definition: pricer_gcg.cpp:3266
abstraction for SCIP pricing types
void GCGupdateVarStatistics(SCIP *scip, SCIP *origprob, SCIP_VAR *newvar, SCIP_Real redcost)
Definition: gcgvar.c:1761
SCIP_RETCODE GCGpricerAddCol(SCIP *scip, GCG_COL *col)
Definition: pricer_gcg.cpp:4764
public methods for GCG variables
SCIP_Bool GCGisPricingprobRelevant(SCIP *scip, int pricingprobnr)
Definition: relax_gcg.c:4000
const FarkasPricing * getFarkasPricing() const
Definition: objpricer_gcg.h:172
void GCGpricestoreEndFarkas(GCG_PRICESTORE *pricestore)
Definition: pricestore_gcg.c:163
SCIP_DECL_PRICEREXITSOL(ObjPricerGcg::scip_exitsol)
Definition: pricer_gcg.cpp:3677
SCIP_VAR ** GCGlinkingVarGetPricingVars(SCIP_VAR *var)
Definition: gcgvar.c:409
SCIP_RETCODE GCGcreateNewMasterVarFromGcgCol(SCIP *scip, SCIP_Bool infarkas, GCG_COL *gcgcol, SCIP_Bool force, SCIP_Bool *added, SCIP_VAR **addedvar, SCIP_Real score)
Definition: pricer_gcg.cpp:3215
int GCGpricestoreGetNEfficaciousCols(GCG_PRICESTORE *pricestore)
Definition: pricestore_gcg.c:729
SCIP_RETCODE GCGcolpoolPrice(SCIP *scip, GCG_COLPOOL *colpool, GCG_PRICESTORE *pricestore, SCIP_SOL *sol, SCIP_Bool *foundvars)
Definition: colpool.c:352
SCIP_RETCODE GCGsetPricingObjs(SCIP *scip, SCIP_Real *dualsolconv)
Definition: pricer_gcg.cpp:3168
SCIP_RETCODE GCGmasterPrintSimplexIters(SCIP *scip, FILE *file)
Definition: pricer_gcg.cpp:5229
SCIP_RETCODE SCIPactivateEventHdlrDisplay(SCIP *scip)
Definition: event_display.c:64
SCIP_RETCODE GCGcolpoolCreate(SCIP *scip, GCG_COLPOOL **colpool, int agelimit)
Definition: colpool.c:159
SCIP_RETCODE GCGcolUpdateMastercuts(GCG_COL *gcgcol, SCIP_Real *newmastercuts, int nnewmastercuts)
Definition: gcgcol.c:584
SCIP_EXPORT SCIP_Bool GCGsolverIsHeurEnabled(GCG_SOLVER *solver)
Definition: solver.c:428
SCIP_RETCODE SCIPincludePricerGcg(SCIP *scip, SCIP *origprob)
Definition: pricer_gcg.cpp:4112
SCIP_EXPORT SCIP_Real GCGsolverGetOptRedcostTime(SCIP *scip, GCG_SOLVER *solver)
Definition: solver.c:500
Definition: class_pricingtype.h:194
Definition: class_pricingtype.h:156
SCIP_RETCODE GCGcomputeColMastercoefs(SCIP *scip, GCG_COL *gcgcol)
Definition: pricer_gcg.cpp:3246
int GCGpricingprobGetProbnr(GCG_PRICINGPROB *pricingprob)
Definition: pricingprob.c:204
SCIP_RETCODE setPricingObjs(PricingType *pricetype, SCIP_Bool stabilize)
Definition: pricer_gcg.cpp:704
int GCGpricingprobGetNImpCols(GCG_PRICINGPROB *pricingprob)
Definition: pricingprob.c:287
SCIP_RETCODE GCGlinkingVarGetBlocks(SCIP_VAR *var, int nblocks, int *blocks)
Definition: gcgvar.c:450
SCIP_RETCODE SCIPsepaBasisAddPPObjConss(SCIP *scip, int ppnumber, SCIP_Real dualsolconv, SCIP_Bool newcuts)
Definition: sepa_basis.c:1869
SCIP_RETCODE GCGcolSetInitializedCoefs(GCG_COL *gcgcol)
Definition: gcgcol.c:502
SCIP_Bool GCGpricingprobBranchconsIsAdded(GCG_PRICINGPROB *pricingprob)
Definition: pricingprob.c:244
SCIP_Real getDualconvsum(GCG_COL **bestcols)
Definition: pricer_gcg.cpp:1699