Merge remote-tracking branch 'origin/v9-minor'

Author: scip-ci

CHANGELOG

@@ -141,6 +141,8 @@ Performance improvements
 Examples and applications
 -------------------------
 
+- in example Binpacking implement Farkas pricing for packings because branching can actually lead to infeasible restricted master LPs
+
 Unit tests
 ----------
 

examples/Binpacking/src/branch_ryanfoster.c

@@ -204,19 +204,14 @@ SCIP_DECL_BRANCHEXECLP(branchExeclpRyanFoster)
 
          if( bestvalue < value )
          {
-            /* there is no variable with (fractional) LP value > 0 that contains exactly one of the items */
-            if( SCIPisEQ(scip, pairweights[i][j], pairweights[i][i])
-               && SCIPisEQ(scip, pairweights[i][j], pairweights[j][j]) )
-               continue;
-
             bestvalue = value;
             id1 = j;
             id2 = i;
          }
       }
    }
 
-   assert( bestvalue > 0.0 );
+   assert( SCIPisFeasPositive(scip, bestvalue) );
    assert( id1 >= 0 && id1 < nitems);
    assert( id2 >= 0 && id2 < nitems);
 

examples/Binpacking/src/cons_samediff.c

@@ -49,7 +49,7 @@
 #define CONSHDLR_NAME          "samediff"
 #define CONSHDLR_DESC          "stores the local branching decisions"
 #define CONSHDLR_ENFOPRIORITY         0 /**< priority of the constraint handler for constraint enforcing */
-#define CONSHDLR_CHECKPRIORITY  9999999 /**< priority of the constraint handler for checking feasibility */
+#define CONSHDLR_CHECKPRIORITY -9999999 /**< priority of the constraint handler for checking feasibility */
 #define CONSHDLR_PROPFREQ             1 /**< frequency for propagating domains; zero means only preprocessing propagation */
 #define CONSHDLR_EAGERFREQ            1 /**< frequency for using all instead of only the useful constraints in separation,
                                          *   propagation and enforcement, -1 for no eager evaluations, 0 for first only */

examples/Binpacking/src/pricer_binpacking.c

@@ -50,28 +50,16 @@
  *
  * To solve the above integer program, we create a new SCIP instance within SCIP and use the usual functions to create
  * variables and constraints. Besides, we need the current dual solutions to all set covering constraints (each stands
- * for one item) which are the objective coefficients of the binary variables. Therefore, we use the function
- * SCIPgetDualsolSetppc() which returns the dual solutions for the given set covering constraint.
+ * for one item) which are the objective coefficients of the binary variables. Therefore, we use the functions
+ * SCIPgetDualsolSetppc() and SCIPgetDualfarkasSetppc() which return the dual solution or ray for the given set
+ * covering constraint for a feasible or infeasible restricted master LP.
  *
  * Since we also want to generate new variables during search, we have to care that we do not generate variables over
  * and over again. For example, if we branched or fixed a certain packing to zero, we have to make sure that we do not
  * generate the corresponding variables at that node again. For this, we have to add constraints forbidding to generate
  * variables which are locally fixed to zero. See the function addFixedVarsConss() for more details. While using the
  * \ref BINPACKING_BRANCHING "Ryan/Foster branching", we also have to ensure that these branching decisions are respected. This is
  * realized within the function addBranchingDecisionConss().
- *
- * @note In case of this binpacking example, the master LP should not get infeasible after branching, because of the way
- *       branching is performed. Therefore, the Farkas pricing is not implemented.
- *       1. In case of Ryan/Foster branching, the two items are selected in a way such that the sum of the LP values of
- *          all columns/packings containing both items is fractional. Hence, it exists at least one column/packing which
- *          contains both items and also at least one column/packing for each item containing this but not the other
- *          item. That means, branching in the "same" direction stays LP feasible since there exists at least one
- *          column/packing with both items and branching in the "differ" direction stays LP feasible since there exists
- *          at least one column/packing containing one item, but not the other.
- *       2. In case of variable branching, we only branch on fractional variables. If a variable is fixed to one, there
- *          is no issue.  If a variable is fixed to zero, then we know that for each item which is part of that
- *          column/packing, there exists at least one other column/packing containing this particular item due to the
- *          covering constraints.
  */
 
 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
@@ -338,6 +326,7 @@ static
 SCIP_RETCODE initPricing(
    SCIP*                 scip,               /**< SCIP data structure */
    SCIP_PRICERDATA*      pricerdata,         /**< pricer data */
+   SCIP_Bool             isfarkas,           /**< whether we perform Farkas pricing */
    SCIP*                 subscip,            /**< pricing SCIP data structure */
    SCIP_VAR**            vars                /**< variable array for the items */
    )
@@ -387,8 +376,8 @@ SCIP_RETCODE initPricing(
       }
 
       /* dual value in original SCIP */
-      dual = SCIPgetDualsolSetppc(scip, cons);
-      
+      dual = isfarkas ? SCIPgetDualfarkasSetppc(scip, cons) : SCIPgetDualsolSetppc(scip, cons);
+
       SCIP_CALL( SCIPcreateVarBasic(subscip, &var, SCIPconsGetName(cons), 0.0, 1.0, dual, SCIP_VARTYPE_BINARY) );
       SCIP_CALL( SCIPaddVar(subscip, var) );
 
@@ -417,99 +406,15 @@ SCIP_RETCODE initPricing(
    return SCIP_OKAY;
 }
 
-/**@} */
-
-/**name Callback methods
- *
- * @{
- */
-
-/** destructor of variable pricer to free user data (called when SCIP is exiting) */
+/** perform packing pricing */
 static
-SCIP_DECL_PRICERFREE(pricerFreeBinpacking)
-{
-   SCIP_PRICERDATA* pricerdata;
-
-   assert(scip != NULL);
-   assert(pricer != NULL);
-
-   pricerdata = SCIPpricerGetData(pricer);
-
-   if( pricerdata != NULL)
-   {
-      /* free memory */
-      SCIPfreeBlockMemoryArrayNull(scip, &pricerdata->conss, pricerdata->nitems);
-      SCIPfreeBlockMemoryArrayNull(scip, &pricerdata->weights, pricerdata->nitems);
-      SCIPfreeBlockMemoryArrayNull(scip, &pricerdata->ids, pricerdata->nitems);
-
-      SCIPfreeBlockMemory(scip, &pricerdata);
-   }
-
-   return SCIP_OKAY;
-}
-
-
-/** initialization method of variable pricer (called after problem was transformed) */
-static
-SCIP_DECL_PRICERINIT(pricerInitBinpacking)
-{  /*lint --e{715}*/
-   SCIP_PRICERDATA* pricerdata;
-   SCIP_CONS* cons;
-   int c;
-
-   assert(scip != NULL);
-   assert(pricer != NULL);
-
-   pricerdata = SCIPpricerGetData(pricer);
-   assert(pricerdata != NULL);
-
-   /* get transformed constraints */
-   for( c = 0; c < pricerdata->nitems; ++c )
-   {
-      cons = pricerdata->conss[c];
-
-      /* release original constraint */
-      SCIP_CALL( SCIPreleaseCons(scip, &pricerdata->conss[c]) );
-
-      /* get transformed constraint */
-      SCIP_CALL( SCIPgetTransformedCons(scip, cons, &pricerdata->conss[c]) );
-
-      /* capture transformed constraint */
-      SCIP_CALL( SCIPcaptureCons(scip, pricerdata->conss[c]) );
-   }
-
-   return SCIP_OKAY;
-}
-
-
-/** solving process deinitialization method of variable pricer (called before branch and bound process data is freed) */
-static
-SCIP_DECL_PRICEREXITSOL(pricerExitsolBinpacking)
+SCIP_RETCODE doPricing(
+   SCIP*                 scip,               /**< SCIP data structure */
+   SCIP_PRICER*          pricer,             /**< variable pricer structure */
+   SCIP_Bool             isfarkas,           /**< whether we perform Farkas pricing */
+   SCIP_RESULT*          result              /**< pointer to store the result */
+   )
 {
-   SCIP_PRICERDATA* pricerdata;
-   int c;
-
-   assert(scip != NULL);
-   assert(pricer != NULL);
-
-   pricerdata = SCIPpricerGetData(pricer);
-   assert(pricerdata != NULL);
-
-   /* get release constraints */
-   for( c = 0; c < pricerdata->nitems; ++c )
-   {
-      /* release constraint */
-      SCIP_CALL( SCIPreleaseCons(scip, &(pricerdata->conss[c])) );
-   }
-
-   return SCIP_OKAY;
-}
-
-
-/** reduced cost pricing method of variable pricer for feasible LPs */
-static
-SCIP_DECL_PRICERREDCOST(pricerRedcostBinpacking)
-{  /*lint --e{715}*/
    SCIP* subscip;
    SCIP_PRICERDATA* pricerdata;
    SCIP_CONS** conss;
@@ -529,6 +434,7 @@ SCIP_DECL_PRICERREDCOST(pricerRedcostBinpacking)
 
    assert(scip != NULL);
    assert(pricer != NULL);
+   assert(result != NULL);
 
    (*result) = SCIP_DIDNOTRUN;
 
@@ -571,7 +477,7 @@ SCIP_DECL_PRICERREDCOST(pricerRedcostBinpacking)
    SCIP_CALL( SCIPallocBufferArray(scip, &vars, nitems) );
 
    /* initialization local pricing problem */
-   SCIP_CALL( initPricing(scip, pricerdata, subscip, vars) );
+   SCIP_CALL( initPricing(scip, pricerdata, isfarkas, subscip, vars) );
 
    SCIPdebugMsg(scip, "solve pricer problem\n");
 
@@ -582,8 +488,9 @@ SCIP_DECL_PRICERREDCOST(pricerRedcostBinpacking)
    nsols = SCIPgetNSols(subscip);
    addvar = FALSE;
 
-   /* loop over all solutions and create the corresponding column to master if the reduced cost are negative for master,
-    * that is the objective value i greater than 1.0
+   /* loop over all solutions and create the corresponding column to master if the reduced cost is negative for a
+    * feasible dual solution of the restricted master LP, that is, the objective value is greater than 1.0 if the LP is
+    * feasible or greater than 0.0 if the LP is infeasible
     */
    for( s = 0; s < nsols; ++s )
    {
@@ -605,8 +512,8 @@ SCIP_DECL_PRICERREDCOST(pricerRedcostBinpacking)
          continue;
       }
 
-      /* check if the solution has a value greater than 1.0 */
-      if( SCIPisFeasGT(subscip, SCIPgetSolOrigObj(subscip, sol), 1.0) )
+      /* check if the solution has a value greater than 1.0 in redcost pricing or greater than 0.0 in Farkas pricing */
+      if( SCIPisFeasGT(subscip, SCIPgetSolOrigObj(subscip, sol), isfarkas ? 0.0 : 1.0) )
       {
          SCIP_VAR* var;
          SCIP_VARDATA* vardata;
@@ -648,7 +555,7 @@ SCIP_DECL_PRICERREDCOST(pricerRedcostBinpacking)
 
          SCIP_CALL( SCIPvardataCreateBinpacking(scip, &vardata, consids, nconss) );
 
-         /* create variable for a new column with objective function coefficient 0.0 */
+         /* create variable for a new column with objective function coefficient 1.0 */
          SCIP_CALL( SCIPcreateVarBinpacking(scip, &var, name, 1.0, FALSE, TRUE, vardata) );
 
          /* add the new variable to the pricer store */
@@ -690,27 +597,110 @@ SCIP_DECL_PRICERREDCOST(pricerRedcostBinpacking)
    return SCIP_OKAY;
 }
 
+/**@} */
+
+/**name Callback methods
+ *
+ * @{
+ */
+
+/** destructor of variable pricer to free user data (called when SCIP is exiting) */
+static
+SCIP_DECL_PRICERFREE(pricerFreeBinpacking)
+{
+   SCIP_PRICERDATA* pricerdata;
+
+   assert(scip != NULL);
+   assert(pricer != NULL);
+
+   pricerdata = SCIPpricerGetData(pricer);
+
+   if( pricerdata != NULL)
+   {
+      /* free memory */
+      SCIPfreeBlockMemoryArrayNull(scip, &pricerdata->conss, pricerdata->nitems);
+      SCIPfreeBlockMemoryArrayNull(scip, &pricerdata->weights, pricerdata->nitems);
+      SCIPfreeBlockMemoryArrayNull(scip, &pricerdata->ids, pricerdata->nitems);
+
+      SCIPfreeBlockMemory(scip, &pricerdata);
+   }
+
+   return SCIP_OKAY;
+}
+
+
+/** initialization method of variable pricer (called after problem was transformed) */
+static
+SCIP_DECL_PRICERINIT(pricerInitBinpacking)
+{  /*lint --e{715}*/
+   SCIP_PRICERDATA* pricerdata;
+   SCIP_CONS* cons;
+   int c;
+
+   assert(scip != NULL);
+   assert(pricer != NULL);
+
+   pricerdata = SCIPpricerGetData(pricer);
+   assert(pricerdata != NULL);
+
+   /* get transformed constraints */
+   for( c = 0; c < pricerdata->nitems; ++c )
+   {
+      cons = pricerdata->conss[c];
+
+      /* release original constraint */
+      SCIP_CALL( SCIPreleaseCons(scip, &pricerdata->conss[c]) );
+
+      /* get transformed constraint */
+      SCIP_CALL( SCIPgetTransformedCons(scip, cons, &pricerdata->conss[c]) );
+
+      /* capture transformed constraint */
+      SCIP_CALL( SCIPcaptureCons(scip, pricerdata->conss[c]) );
+   }
+
+   return SCIP_OKAY;
+}
+
+
+/** solving process deinitialization method of variable pricer (called before branch and bound process data is freed) */
+static
+SCIP_DECL_PRICEREXITSOL(pricerExitsolBinpacking)
+{
+   SCIP_PRICERDATA* pricerdata;
+   int c;
+
+   assert(scip != NULL);
+   assert(pricer != NULL);
+
+   pricerdata = SCIPpricerGetData(pricer);
+   assert(pricerdata != NULL);
+
+   /* get release constraints */
+   for( c = 0; c < pricerdata->nitems; ++c )
+   {
+      /* release constraint */
+      SCIP_CALL( SCIPreleaseCons(scip, &(pricerdata->conss[c])) );
+   }
+
+   return SCIP_OKAY;
+}
+
+/** reduced cost pricing method of variable pricer for feasible LPs */
+static
+SCIP_DECL_PRICERREDCOST(pricerRedcostBinpacking)
+{  /*lint --e{715}*/
+   SCIP_CALL( doPricing(scip, pricer, FALSE, result) );
+
+   return SCIP_OKAY;
+}
+
 /** farkas pricing method of variable pricer for infeasible LPs */
 static
 SCIP_DECL_PRICERFARKAS(pricerFarkasBinpacking)
 {  /*lint --e{715}*/
-   /** @note In case of this binpacking example, the master LP should not get infeasible after branching, because of the
-    *        way branching is performed. Therefore, the Farkas pricing is not implemented.
-    *        1. In case of Ryan/Foster branching, the two items are selected in a way such that the sum of the LP values
-    *           of all columns/packings containing both items is fractional. Hence, it exists at least one
-    *           column/packing which contains both items and also at least one column/packing for each item containing
-    *           this but not the other item. That means, branching in the "same" direction stays LP feasible since there
-    *           exists at least one column/packing with both items and branching in the "differ" direction stays LP
-    *           feasible since there exists at least one column/packing containing one item, but not the other.
-    *        2. In case of variable branching, we only branch on fractional variables. If a variable is fixed to one,
-    *           there is no issue.  If a variable is fixed to zero, then we know that for each item which is part of
-    *           that column/packing, there exists at least one other column/packing containing this particular item due
-    *           to the covering constraints.
-    */
-   SCIPwarningMessage(scip, "Current master LP is infeasible, but Farkas pricing was not implemented\n");
-   SCIPABORT();
+   SCIP_CALL( doPricing(scip, pricer, TRUE, result) );
 
-   return SCIP_OKAY; /*lint !e527*/
+   return SCIP_OKAY;
 }
 
 /**@} */

examples/maketestallexamples.sh

@@ -14,8 +14,6 @@ set -e
 EXAMPLES=$(for f in *;do if [[ -d $f  ]]; then echo $f;fi; done)
 # Sudoku doesn't have a test
 EXAMPLES=$(echo "$EXAMPLES" |grep -v Sudoku)
-# Binpacking tests are known to fail, #3712
-EXAMPLES=$(echo "$EXAMPLES" |grep -v Binpacking)
 
 LPSOLVERS=(spx2)
 OPTS=(dbg)