move callback to calculate extended master cons coefficients to the gcg branch rule struct

Author: erik-m

CHANGELOG

@@ -74,6 +74,7 @@ New/modified/removed API functions:
 - added function 'GCGpricingmodificationCreate'
 - added function 'GCGextendedmasterconsCreateFromCons'
 - added function 'GCGextendedmasterconsCreateFromRow'
+- added function 'GCGbranchCreateExtendedmastercons'
 - added function 'GCGextendedmasterconsFree'
 - added function 'GCGrelaxBranchNewCol'
 - added function 'GCGrelaxBranchGetExtendedMasterCons'
@@ -82,6 +83,7 @@ New/modified/removed API functions:
 - added callback 'GCG_DECL_BRANCHGETEXTENDEDMASTERCONS' to 'GCG_BRANCHRULE'
 - added parameter 'GCG_DECL_BRANCHNEWCOL ((*branchnewcol));' to 'GCGrelaxIncludeBranchrule'
 - added parameter 'GCG_DECL_BRANCHGETEXTENDEDMASTERCONS((*branchgetextendedmastercons))' to 'GCGrelaxIncludeBranchrule'
+- added parameter 'GCG_DECL_BRANCHGETEXTENDEDMASTERCONSCOEFF((*branchgetextendedmasterconscoeff))' to 'GCGrelaxIncludeBranchrule'
 - moved function 'SCIPincludeSepaMaster' to 'SCIPincludeSepaOriginal'
 - moved function 'GCGsepaGetOrigcuts' to 'GCGsepaGetOriginalSepaOrigcuts'
 - moved function 'GCGsepaGetNCuts' to 'GCGsepaGetNOriginalSepaCuts'

Makefile

@@ -257,6 +257,7 @@ LIBOBJ = \
 			gcg/branch_empty.o \
 			gcg/branch_generic.o \
 			gcg/benders_gcg.o \
+			gcg/branchgcg.o \
 			gcg/branch_orig.o \
 			gcg/branch_relpsprob.o \
 			gcg/branch_ryanfoster.o \

doc/resources/devs/howtoadd/own-branching-rule.md

@@ -220,4 +220,7 @@ The BRANCHDATADELETE callback is called when a branch-and-bound node is freed an
 The BRANCHNEWCOL callback is called whenever a new column is added to the master problem. It can be used to update any branching constraints that were added to the master problem, e.g. to determine and add the coefficient of the new master variable to the corresponding branching constraint.
 
 ### BRANCHGETEXTENDEDMASTERCONS
-If the branching rule branches in the master problem, generating a constraint that can be enforced only if the pricing problem is modified, then the BRANCHGETEXTENDEDMASTERCONS callback will be used by GCG to retrieve the master branching constraint as well as the corresponding modifications to be applied in the pricing problems.
+If the branching rule branches in the master problem, generating a constraint that can be enforced only if the pricing problem is modified, then the BRANCHGETEXTENDEDMASTERCONS callback will be used by GCG to retrieve the master branching constraint as well as the corresponding modifications to be applied in the pricing problems.
+
+### GCG_DECL_BRANCHGETEXTENDEDMASTERCONSCOEFF
+If the branching rule branches in the master problem, generating an extended master constraint, the callback will be used to determine the coefficient of a column solution in the extended master constraint.

doc/resources/devs/howtouse/masterextendedconss.md

@@ -46,6 +46,7 @@ We advise using the following interfaces:
  - create modifications with `GCGpricingmodificationCreate()`
  - create an extended master constraint around a `SCIP_CONS` with `GCGextendedmasterconsCreateFromCons()`
  - create an extended master constraint around a `SCIP_ROW` with `GCGextendedmasterconsCreateFromRow()`
+ - to create an extended master constraint for branching use `GCGbranchCreateExtendedmastercons` that uses `GCGextendedmasterconsCreateFromCons()`
 
 
 ## Usage
@@ -63,7 +64,7 @@ SCIP_VAR* coefvar = NULL;
 char coefvarName[SCIP_MAXSTRLEN];
 (void) SCIPsnprintf(coefvarName, SCIP_MAXSTRLEN, "y");
 // here, we create a binary variable
-SCIP_CALL( GCGcreateInferredPricingVar(pricingscip, coefvar, coefvarName, 0.0, 1.0, 0.0, SCIP_VARTYPE_BINARY, blocknr) );
+SCIP_CALL( GCGcreateInferredPricingVar(pricingscip, coefvar, coefvarName, 0.0, 1.0, TRUE, 0.0, SCIP_VARTYPE_BINARY, blocknr) );
 
 /* create additional constraints (and inferred pricing variables) */
 SCIP_CONS** additionalcons = NULL;
@@ -96,14 +97,14 @@ SCIP_CALL( GCGpricingmodificationCreate(
 
 /* create the extended master constraint */
 GCG_EXTENDEDMASTERCONSDATA* extendedmasterconsdata = NULL;
-SCIP_CALL( GCGextendedmasterconsCreateFromCons(
-   masterscip,
+SCIP_CALL( GCGbranchCreateExtendedmastercons(
+   gcg,
+   gcgbranchrule,
    extendedmasterconsdata,
    mastercons,
    pricingmods,
    npricingmods,
-   branchdata,
-   extendedmasterconsGetCoeffCompBnd
+   branchdata
 ) );
 ```
 
@@ -112,8 +113,42 @@ SCIP_CALL( GCGextendedmasterconsCreateFromCons(
 static
 GCG_DECL_BRANCHGETEXTENDEDMASTERCONS(branchGetExtendedmasterconsCompBnd)
 {
-   // grab the extended master cons, e.g. from the branchdata
-   *extendedmasterconsdata = branchdata->extendedmasterconsdata;
+   assert(gcg != NULL);
+
+   assert(branchdata != NULL);
+   assert(branchdata->mastercons != NULL);
+
+   *extendedmasterconsdata = branchdata->mastercons;
+
+   return SCIP_OKAY;
+}
+```
+
+Furthermore, we implement a callback that calculates the coefficient of a column solution in the extended master constraint:
+```C
+static
+GCG_DECL_BRANCHGETEXTENDEDMASTERCONSCOEFF(branchGetExtendedmasterconsCoeffCompBnd)
+{
+   SCIP* masterprob;
+
+   masterprob = GCGgetMasterprob(gcg);
+
+   assert(masterprob != NULL);
+   assert(GCGisMaster(masterprob));
+
+   assert(branchdata != NULL);
+   assert(branchdata->mastercons == extendedmasterconsdata);
+
+   *coef = 0.0;
+
+   if( probnr == -1 || probnr != branchdata->blocknr )
+      return SCIP_OKAY;
+
+   if( !isColInCompBndSeq(masterprob, solvars, solvals, nsolvars, branchdata->compBndSeq, branchdata->compBndSeqSize) )
+      return SCIP_OKAY;
+
+   *coef = 1.0;
+
    return SCIP_OKAY;
 }
 ```

src/CMakeLists.txt

@@ -15,6 +15,7 @@ set(CMAKE_C_STANDARD_REQUIRED on)
 set(gcgsources
     gcg/benders_gcg.c
     gcg/bendersplugins.c
+    gcg/branchgcg.c
     gcg/branch_bpstrong.c
     gcg/branch_compbnd.c
     gcg/branch_empty.c
@@ -166,6 +167,7 @@ set(gcggraphsources
 )
 
 set(gcgheaders
+    gcg/branchgcg.h
     gcg/branch_empty.h
     gcg/branch_bpstrong.h
     gcg/branch_compbnd.h
@@ -268,6 +270,7 @@ set(gcgheaders
     gcg/pub_pricingcb.h
     gcg/pricingjob.h
     gcg/pricingprob.h
+    gcg/pub_branchgcg.h
     gcg/pub_clscons.h
     gcg/pub_clsvar.h
     gcg/pub_colpool.h

src/gcg/branch_bpstrong.c

@@ -1548,9 +1548,9 @@ SCIP_DECL_BRANCHINIT(branchInitBPStrong)
 
    SCIPdebugMessage("Init BPStrong branching rule\n");
 
-   SCIP_CALL( GCGrelaxIncludeBranchrule(branchruledata->gcg, branchrule, branchActiveMasterBPStrong,
+   SCIP_CALL( GCGrelaxIncludeBranchrule(branchruledata->gcg, branchrule, NULL, branchActiveMasterBPStrong,
          branchDeactiveMasterBPStrong, branchPropMasterBPStrong, branchMasterSolvedBPStrong,
-         branchDataDeleteBPStrong, NULL, NULL) );
+         branchDataDeleteBPStrong, NULL, NULL, NULL) );
 
    /* free data if we already solved another instance but branchFreeBPStrong was not called inbetween */
    if( branchruledata->initialized )

src/gcg/branch_compbnd.c

@@ -80,6 +80,7 @@
 struct SCIP_BranchruleData
 {
    GCG*                  gcg;                            /**< GCG data structure */
+   GCG_BRANCHRULE*       gcgbranchrule;                  /**< GCG branchrule structure */
    SCIP_Bool             useMaxRangeMidrangeHeuristic;   /** should the MaxRangeMidrangeHeuristic be used */
    SCIP_Bool             useMostDistinctMedianHeuristic; /** should the MostDistinctMedianHeuristic be used */
 #ifdef COMPBND_STATS
@@ -387,7 +388,7 @@ SCIP_RETCODE addVarToMasterbranch(
 
    *added = FALSE;
 
-   coef = GCGextendedmasterconsGetCoeff(gcg, branchdata->mastercons, origvars, origvals, norigvars, GCGvarGetBlock(mastervar));
+   SCIP_CALL( GCGextendedmasterconsGetCoeff(gcg, branchdata->mastercons, origvars, origvals, norigvars, GCGvarGetBlock(mastervar), &coef) );
 
    if( !SCIPisZero(masterprob, coef) )
    {
@@ -401,18 +402,15 @@ SCIP_RETCODE addVarToMasterbranch(
 
 /** callback new column method */
 static
-GCG_DECL_EXTENDEDMASTERCONSGETCOEFF(extendedmasterconsGetCoeffCompBnd)
+GCG_DECL_BRANCHGETEXTENDEDMASTERCONSCOEFF(branchGetExtendedmasterconsCoeffCompBnd)
 {
    SCIP* masterprob;
-   GCG_BRANCHDATA* branchdata;
 
    masterprob = GCGgetMasterprob(gcg);
 
    assert(masterprob != NULL);
    assert(GCGisMaster(masterprob));
 
-   branchdata = (GCG_BRANCHDATA*) GCGextendedmasterconsGetData(extendedmasterconsdata);
-
    assert(branchdata != NULL);
    assert(branchdata->mastercons == extendedmasterconsdata);
 
@@ -433,6 +431,7 @@ GCG_DECL_EXTENDEDMASTERCONSGETCOEFF(extendedmasterconsGetCoeffCompBnd)
 static
 SCIP_RETCODE createBranchingCons(
    GCG*                  gcg,                /**< GCG data structure */
+   SCIP_BRANCHRULE*      branchrule,         /**< branch rule structure */
    SCIP_NODE*            node,               /**< node to add constraint */
    GCG_BRANCHDATA*       branchdata          /**< branching data structure */
 )
@@ -441,6 +440,7 @@ SCIP_RETCODE createBranchingCons(
 
    SCIP* pricingscip;
    SCIP* masterprob;
+   SCIP_BRANCHRULEDATA* branchruledata;
 
    SCIP_VAR** mastervars;
    int nmastervars;
@@ -466,6 +466,9 @@ SCIP_RETCODE createBranchingCons(
    assert(branchdata != NULL);
    assert(branchdata->mastercons == NULL);
 
+   branchruledata = SCIPbranchruleGetData(branchrule);
+   assert(branchruledata != NULL);
+
    uuid = SCIPnodeGetNumber(node);
 
    mastervars = SCIPgetVars(masterprob);
@@ -634,7 +637,7 @@ SCIP_RETCODE createBranchingCons(
    ) );
 
    // create the master constraint
-   SCIP_CALL( GCGextendedmasterconsCreateFromCons(gcg, &branchdata->mastercons, branchcons, pricingmods, 1, branchdata, extendedmasterconsGetCoeffCompBnd) );
+   SCIP_CALL( GCGbranchCreateExtendedmastercons(gcg, branchruledata->gcgbranchrule, &branchdata->mastercons, branchcons, pricingmods, 1, branchdata) );
 
    // add the variables to the constraint
    for( i = 0; i < nmastervars; i++ )
@@ -728,13 +731,13 @@ SCIP_RETCODE createChildNodesCompBndSeq(
    SCIP_CALL( GCGcreateConsMasterbranch(gcg, &downChildcons, downChildname, downChild,
       GCGconsMasterbranchGetActiveCons(gcg), branchrule, downBranchData, NULL, 0, 0) );
    SCIP_CALL( SCIPaddConsNode(masterprob, downChild, downChildcons, NULL) );
-   SCIP_CALL( createBranchingCons(gcg, downChild, downBranchData) );
+   SCIP_CALL( createBranchingCons(gcg, branchrule, downChild, downBranchData) );
 
    SCIP_CALL( SCIPcreateChild(masterprob, &upChild, 0.0, SCIPgetLocalTransEstimate(masterprob)) );
    SCIP_CALL( GCGcreateConsMasterbranch(gcg, &upChildcons, upChildname, upChild,
       GCGconsMasterbranchGetActiveCons(gcg), branchrule, upBranchData, NULL, 0, 0) );
    SCIP_CALL( SCIPaddConsNode(masterprob, upChild, upChildcons, NULL) );
-   SCIP_CALL( createBranchingCons(gcg, upChild, upBranchData) );
+   SCIP_CALL( createBranchingCons(gcg, branchrule, upChild, upBranchData) );
 
    /*  release constraints */
    SCIP_CALL( SCIPreleaseCons(masterprob, &upChildcons) );
@@ -2066,7 +2069,6 @@ SCIP_DECL_BRANCHINIT(branchInitCompBnd)
 {
    SCIP_BRANCHRULEDATA* branchruledata;
 #ifdef COMPBND_STATS
-   SCIP_BRANCHRULEDATA* branchruledata;
    SCIP_Bool stabilization_tree;
 #endif
 
@@ -2082,9 +2084,9 @@ SCIP_DECL_BRANCHINIT(branchInitCompBnd)
 
    SCIPdebugMessage("Init method of component bound branching\n");
 
-   SCIP_CALL( GCGrelaxIncludeBranchrule(branchruledata->gcg, branchrule, branchActiveMasterCompBnd,
+   SCIP_CALL( GCGrelaxIncludeBranchrule(branchruledata->gcg, branchrule, &branchruledata->gcgbranchrule, branchActiveMasterCompBnd,
          branchDeactiveMasterCompBnd, branchPropMasterCompBnd, branchMasterSolvedCompBnd, branchDataDeleteCompBnd,
-         branchNewColCompBnd, branchGetExtendedmasterconsCompBnd) );
+         branchNewColCompBnd, branchGetExtendedmasterconsCompBnd, branchGetExtendedmasterconsCoeffCompBnd) );
 
 #ifdef COMPBND_STATS
    /* determine the filename */
@@ -2139,6 +2141,7 @@ SCIP_RETCODE GCGincludeBranchruleCompBnd(
    /* create compbnd branching rule data */
    SCIP_CALL( SCIPallocBlockMemory(masterprob, &branchruledata) );
    branchruledata->gcg = gcg;
+   branchruledata->gcgbranchrule = NULL;
 
    SCIPdebugMessage("Include method of component bound branching\n");
 

src/gcg/branch_generic.c

@@ -2986,8 +2986,8 @@ SCIP_DECL_BRANCHINIT(branchInitGeneric)
 
    SCIPdebugMessage("Init method of Vanderbecks generic branching\n");
 
-   SCIP_CALL( GCGrelaxIncludeBranchrule(branchruledata->gcg, branchrule, NULL,
-         NULL, branchPropMasterGeneric, NULL, branchDataDeleteGeneric, branchNewColGeneric, NULL) );
+   SCIP_CALL( GCGrelaxIncludeBranchrule(branchruledata->gcg, branchrule, NULL, NULL,
+         NULL, branchPropMasterGeneric, NULL, branchDataDeleteGeneric, branchNewColGeneric, NULL, NULL) );
 
    return SCIP_OKAY;
 }

src/gcg/branch_orig.c

@@ -831,8 +831,8 @@ SCIP_DECL_BRANCHINIT(branchInitOrig)
 
    SCIPdebugMessage("Init orig branching rule\n");
 
-   SCIP_CALL( GCGrelaxIncludeBranchrule(branchruledata->gcg, branchrule, branchActiveMasterOrig,
-         branchDeactiveMasterOrig, branchPropMasterOrig, branchMasterSolvedOrig, branchDataDeleteOrig, NULL, NULL) );
+   SCIP_CALL( GCGrelaxIncludeBranchrule(branchruledata->gcg, branchrule, NULL, branchActiveMasterOrig,
+         branchDeactiveMasterOrig, branchPropMasterOrig, branchMasterSolvedOrig, branchDataDeleteOrig, NULL, NULL, NULL) );
 
    return SCIP_OKAY;
 }

src/gcg/branch_ryanfoster.c

@@ -946,8 +946,8 @@ SCIP_DECL_BRANCHINIT(branchInitRyanfoster)
    branchruledata = SCIPbranchruleGetData(branchrule);
    assert(branchruledata != NULL);
 
-   SCIP_CALL( GCGrelaxIncludeBranchrule(branchruledata->gcg, branchrule, branchActiveMasterRyanfoster,
-         branchDeactiveMasterRyanfoster, branchPropMasterRyanfoster, NULL, branchDataDeleteRyanfoster, NULL, NULL) );
+   SCIP_CALL( GCGrelaxIncludeBranchrule(branchruledata->gcg, branchrule, NULL, branchActiveMasterRyanfoster,
+         branchDeactiveMasterRyanfoster, branchPropMasterRyanfoster, NULL, branchDataDeleteRyanfoster, NULL, NULL, NULL) );
 
    return SCIP_OKAY;
 }

src/gcg/branch_xyz.c

@@ -108,27 +108,6 @@ SCIP_DECL_BRANCHFREE(branchFreeXyz)
 #endif
 
 
-/** initialization method of branching rule (called after problem was transformed) */
-#ifdef SCIP_DISABLED_CODE
-static
-SCIP_DECL_BRANCHINIT(branchInitXyz)
-{  /*lint --e{715}*/
-
-   /* inform relaxator of GCG about the branching rule */
-   SCIP_CALL( GCGrelaxIncludeBranchrule(scip, branchrule, branchActiveMasterOrig,
-         branchDeactiveMasterOrig, branchPropMasterOrig, branchMasterSolvedOrig, branchDataDeleteOrig,
-         branchNewColXyz, branchGetExtendedMasterConsXyz) );
-
-   SCIPerrorMessage("method of xyz branching rule not implemented yet\n");
-   SCIPABORT(); /*lint --e{527}*/
-
-   return SCIP_OKAY;
-}
-#else
-#define branchInitXyz NULL
-#endif
-
-
 /** deinitialization method of branching rule (called before transformed problem is freed) */
 #ifdef SCIP_DISABLED_CODE
 static
@@ -329,6 +308,43 @@ GCG_DECL_BRANCHGETEXTENDEDMASTERCONS(branchGetExtendedMasterConsXyz)
 #define branchGetExtendedmasterconsXyz NULL
 #endif
 
+/** call to determine the coefficient of a column solution in the extended master cons */
+#ifdef SCIP_DISABLED_CODE
+static
+GCG_DECL_BRANCHGETEXTENDEDMASTERCONSCOEFF(branchGetExtendedmasterconsCoeffXyz)
+{  /*lint --e{715}*/
+   SCIPerrorMessage("method of xyz branching rule not implemented yet\n");
+   SCIPABORT(); /*lint --e{527}*/
+
+   return SCIP_OKAY;
+}
+#else
+#define branchGetExtendedmasterconsCoeffXyz NULL
+#endif
+
+
+/** initialization method of branching rule (called after problem was transformed) */
+#ifdef SCIP_DISABLED_CODE
+static
+SCIP_DECL_BRANCHINIT(branchInitXyz)
+{  /*lint --e{715}*/
+   GCG_BRANCHRULE* gcgbranchrule = NULL;
+
+   /* inform relaxator of GCG about the branching rule */
+   SCIP_CALL( GCGrelaxIncludeBranchrule(scip, branchrule, &gcgbranchrule, branchActiveMasterOrig,
+         branchDeactiveMasterOrig, branchPropMasterOrig, branchMasterSolvedOrig, branchDataDeleteOrig,
+         branchNewColXyz, branchGetExtendedMasterConsXyz, branchGetExtendedmasterconsCoeff) );
+
+   SCIPerrorMessage("method of xyz branching rule not implemented yet\n");
+   SCIPABORT(); /*lint --e{527}*/
+
+   return SCIP_OKAY;
+}
+#else
+#define branchInitXyz NULL
+#endif
+
+
 /*
  * branching rule specific interface methods
  */