Merge branch 'cipfix' into 'v92-bugfix'

add error for parsing and or logicalor cons

See merge request integer/scip!3833

Author: DominikKamp

CHANGELOG

@@ -7,6 +7,7 @@ Fixed bugs
 ----------
 
 - avoid hashmap key error in removal of doubletons and singletons in dual presolve of setppc constraints by skipping tripleton locks
+- when upgrading to xor constraint require parity variable to be enforced integral
 
 Build system
 ------------

src/scip/cons_and.c

@@ -5115,6 +5115,7 @@ SCIP_RETCODE SCIPcreateConsAnd(
    SCIP_CONSHDLRDATA* conshdlrdata;
    SCIP_CONSDATA* consdata;
    SCIP_Bool infeasible;
+   int i;
 
    /* find the AND-constraint handler */
    conshdlr = SCIPfindConshdlr(scip, CONSHDLR_NAME);
@@ -5124,6 +5125,23 @@ SCIP_RETCODE SCIPcreateConsAnd(
       return SCIP_PLUGINNOTFOUND;
    }
 
+   /* check whether resultant variable is binary */
+   if( !SCIPvarIsBinary(resvar) )
+   {
+      SCIPerrorMessage("resultant <%s> is not binary\n", SCIPvarGetName(resvar));
+      return SCIP_INVALIDDATA;
+   }
+
+   /* check whether all variables are binary */
+   for( i = 0; i < nvars; ++i )
+   {
+      if( !SCIPvarIsBinary(vars[i]) )
+      {
+         SCIPerrorMessage("operand <%s> is not binary\n", SCIPvarGetName(vars[i]));
+         return SCIP_INVALIDDATA;
+      }
+   }
+
    conshdlrdata = SCIPconshdlrGetData(conshdlr);
    assert(conshdlrdata != NULL);
 

src/scip/cons_logicor.c

@@ -5445,6 +5445,7 @@ SCIP_RETCODE SCIPcreateConsLogicor(
 {
    SCIP_CONSHDLR* conshdlr;
    SCIP_CONSDATA* consdata;
+   int i;
 
    assert(scip != NULL);
 
@@ -5456,6 +5457,16 @@ SCIP_RETCODE SCIPcreateConsLogicor(
       return SCIP_INVALIDCALL;
    }
 
+   /* check whether all variables are binary */
+   for( i = 0; i < nvars; ++i )
+   {
+      if( !SCIPvarIsBinary(vars[i]) )
+      {
+         SCIPerrorMessage("operand <%s> is not binary\n", SCIPvarGetName(vars[i]));
+         return SCIP_INVALIDDATA;
+      }
+   }
+
    /* create the constraint specific data */
    SCIP_CALL( consdataCreate(scip, &consdata, nvars, vars) );
 

src/scip/cons_or.c

@@ -2244,6 +2244,7 @@ SCIP_RETCODE SCIPcreateConsOr(
    SCIP_CONSHDLR* conshdlr;
    SCIP_CONSHDLRDATA* conshdlrdata;
    SCIP_CONSDATA* consdata;
+   int i;
 
    /* find the or constraint handler */
    conshdlr = SCIPfindConshdlr(scip, CONSHDLR_NAME);
@@ -2253,6 +2254,23 @@ SCIP_RETCODE SCIPcreateConsOr(
       return SCIP_PLUGINNOTFOUND;
    }
 
+   /* check whether resultant variable is binary */
+   if( !SCIPvarIsBinary(resvar) )
+   {
+      SCIPerrorMessage("resultant <%s> is not binary\n", SCIPvarGetName(resvar));
+      return SCIP_INVALIDDATA;
+   }
+
+   /* check whether all variables are binary */
+   for( i = 0; i < nvars; ++i )
+   {
+      if( !SCIPvarIsBinary(vars[i]) )
+      {
+         SCIPerrorMessage("operand <%s> is not binary\n", SCIPvarGetName(vars[i]));
+         return SCIP_INVALIDDATA;
+      }
+   }
+
    conshdlrdata = SCIPconshdlrGetData(conshdlr);
    assert(conshdlrdata != NULL);
 

src/scip/cons_setppc.c

@@ -7090,6 +7090,7 @@ SCIP_RETCODE createConsSetppc(
    SCIP_CONSHDLR* conshdlr;
    SCIP_CONSDATA* consdata;
    SCIP_CONSHDLRDATA* conshdlrdata;
+   int i;
 
    assert(scip != NULL);
 
@@ -7101,6 +7102,16 @@ SCIP_RETCODE createConsSetppc(
       return SCIP_INVALIDCALL;
    }
 
+   /* check whether all variables are binary */
+   for( i = 0; i < nvars; ++i )
+   {
+      if( !SCIPvarIsBinary(vars[i]) )
+      {
+         SCIPerrorMessage("operand <%s> is not binary\n", SCIPvarGetName(vars[i]));
+         return SCIP_INVALIDDATA;
+      }
+   }
+
    /* create the constraint specific data */
    if( SCIPgetStage(scip) == SCIP_STAGE_PROBLEM )
    {

src/scip/cons_xor.c

@@ -4501,7 +4501,7 @@ SCIP_RETCODE createConsXorIntvar(
    SCIP_Bool             rhs,                /**< right hand side of the constraint */
    int                   nvars,              /**< number of operator variables in the constraint */
    SCIP_VAR**            vars,               /**< array with operator variables of constraint */
-   SCIP_VAR*             intvar,             /**< artificial integer variable for linear relaxation */
+   SCIP_VAR*             intvar,             /**< integer variable for linear relaxation or NULL if artificial */
    SCIP_Bool             initial,            /**< should the LP relaxation of constraint be in the initial LP?
                                               *   Usually set to TRUE. Set to FALSE for 'lazy constraints'. */
    SCIP_Bool             separate,           /**< should the constraint be separated during LP processing?
@@ -4529,6 +4529,8 @@ SCIP_RETCODE createConsXorIntvar(
 {
    SCIP_CONSHDLR* conshdlr;
    SCIP_CONSDATA* consdata;
+   SCIP_VARTYPE intvartype;
+   int i;
 
    /* find the xor constraint handler */
    conshdlr = SCIPfindConshdlr(scip, CONSHDLR_NAME);
@@ -4538,6 +4540,28 @@ SCIP_RETCODE createConsXorIntvar(
       return SCIP_PLUGINNOTFOUND;
    }
 
+   /* check whether int variable is integral */
+   if( intvar != NULL )
+   {
+      intvartype = SCIPvarGetType(intvar);
+
+      if( intvartype != SCIP_VARTYPE_BINARY && intvartype != SCIP_VARTYPE_INTEGER )
+      {
+         SCIPerrorMessage("intvar <%s> is not enforced integral\n", SCIPvarGetName(intvar));
+         return SCIP_INVALIDDATA;
+      }
+   }
+
+   /* check whether all variables are binary */
+   for( i = 0; i < nvars; ++i )
+   {
+      if( !SCIPvarIsBinary(vars[i]) )
+      {
+         SCIPerrorMessage("operand <%s> is not binary\n", SCIPvarGetName(vars[i]));
+         return SCIP_INVALIDDATA;
+      }
+   }
+
    /* create constraint data */
    SCIP_CALL( consdataCreate(scip, &consdata, rhs, nvars, vars, intvar) );
 
@@ -4608,6 +4632,7 @@ SCIP_DECL_LINCONSUPGD(linconsUpgdXor)
       {
          SCIP_VAR** xorvars;
          SCIP_VAR* parityvar = NULL;
+         SCIP_VARTYPE parityvartype;
          SCIP_Bool postwo = FALSE;
          int cnt = 0;
          int j;
@@ -4620,6 +4645,15 @@ SCIP_DECL_LINCONSUPGD(linconsUpgdXor)
             if( SCIPisEQ(scip, REALABS(vals[j]), 2.0) )
             {
                parityvar = vars[j];
+               parityvartype = SCIPvarGetType(parityvar);
+
+               /* parity variable requires enforced integrality */
+               if( parityvartype != SCIP_VARTYPE_BINARY && parityvartype != SCIP_VARTYPE_INTEGER )
+               {
+                  parityvar = NULL;
+                  break;
+               }
+
                postwo = (vals[j] > 0.0);
             }
             else if( !SCIPisEQ(scip, REALABS(vals[j]), 1.0) )
@@ -5994,6 +6028,7 @@ SCIP_RETCODE SCIPcreateConsXor(
 {
    SCIP_CONSHDLR* conshdlr;
    SCIP_CONSDATA* consdata;
+   int i;
 
    /* find the xor constraint handler */
    conshdlr = SCIPfindConshdlr(scip, CONSHDLR_NAME);
@@ -6003,6 +6038,16 @@ SCIP_RETCODE SCIPcreateConsXor(
       return SCIP_PLUGINNOTFOUND;
    }
 
+   /* check whether all variables are binary */
+   for( i = 0; i < nvars; ++i )
+   {
+      if( !SCIPvarIsBinary(vars[i]) )
+      {
+         SCIPerrorMessage("operand <%s> is not binary\n", SCIPvarGetName(vars[i]));
+         return SCIP_INVALIDDATA;
+      }
+   }
+
    /* create constraint data */
    SCIP_CALL( consdataCreate(scip, &consdata, rhs, nvars, vars, NULL) );