Merge remote-tracking branch 'origin/v80-bugfix'

src/scip/benders.c

@@ -713,7 +713,7 @@ SCIP_RETCODE addAuxiliaryVariablesToMaster(
       {
          SCIP_VARTYPE vartype;
 
-         /* set the variable type of the auxiliary variables to implied integer if the objective function of the
+         /* set the variable type of the auxiliary variables to implicit integer if the objective function of the
           * subproblem is guaranteed to be integer. This behaviour is controlled through a user parameter.
           * NOTE: It is only possible to determine if the objective function is integral if the subproblem is defined as
           * a SCIP instance, i.e. not NULL.
@@ -1135,7 +1135,7 @@ SCIP_RETCODE doBendersCreate(
 
    (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "benders/%s/auxvarsimplint", name);
    SCIP_CALL( SCIPsetAddBoolParam(set, messagehdlr, blkmem, paramname,
-         "if the subproblem objective is integer, then define the auxiliary variables as implied integers?",
+         "if the subproblem objective is integer, then define the auxiliary variables as implicit integers?",
          &(*benders)->auxvarsimplint, FALSE, SCIP_DEFAULT_AUXVARSIMPLINT, NULL, NULL) ); /*lint !e740*/
 
    (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "benders/%s/cutcheck", name);
@@ -1618,7 +1618,7 @@ SCIP_RETCODE checkSubproblemConvexity(
    /* getting the number of integer and binary variables to determine the problem type */
    SCIP_CALL( SCIPgetVarsData(subproblem, &vars, &nvars, &nbinvars, &nintvars, &nimplintvars, NULL) );
 
-   /* if there are any binary, integer or implied integer variables, then the subproblems is marked as non-convex */
+   /* if there are any binary, integer or implicit integer variables, then the subproblems is marked as non-convex */
    if( nbinvars != 0 || nintvars != 0 || nimplintvars != 0 )
    {
       discretevar = TRUE;

src/scip/branch_lookahead.c

@@ -976,7 +976,7 @@ SCIP_RETCODE level2dataStoreResult(
 typedef struct
 {
    BRANCHINGDECISION*    olddecision;        /**< The previous decision that gets used for the case that in the previous run
-                                              *   only non-violating implied binary constraints were added.*/
+                                              *   only non-violating implicit binary constraints were added.*/
    SCIP_Longint          oldnnodelpiterations; /**< node LP iterations when previous branching decision was stored */
    SCIP_Longint          oldnnodelps;        /**< node LPs when previous branching decision was stored */
    SCIP_Longint          oldntotalnodes;     /**< node at which previous branching decision was stored */
@@ -1013,7 +1013,7 @@ typedef struct
    SCIP_Bool             mergedomainreductions; /**< should domain reductions of feasible siblings should be merged? */
    SCIP_Bool             prefersimplebounds; /**<    should domain reductions only be applied if there are simple bound changes? */
    SCIP_Bool             onlyvioldomreds;    /**< Should only domain reductions that violate the LP solution be applied? */
-   SCIP_Bool             usebincons;         /**< indicates whether the data for the implied binary constraints should
+   SCIP_Bool             usebincons;         /**< indicates whether the data for the implicit binary constraints should
                                               *   be gathered and used */
    int                   addbinconsrow;      /**< should binary constraints be added as rows to the base LP?
                                               *   (0: no, 1: separate, 2: as initial rows) */
@@ -2972,7 +2972,7 @@ void createBinaryConstraintName(
 
 /**
  * Add the constraints found during the lookahead branching.
- * The implied binary bounds were found when two or more consecutive branchings of binary variables were cutoff. Then these
+ * The implicit binary bounds were found when two or more consecutive branchings of binary variables were cutoff. Then these
  * branching constraints can be combined into a single 'binary constraint'.
  */
 static
@@ -6087,7 +6087,7 @@ SCIP_DECL_BRANCHEXECLP(branchExeclpLookahead)
       if( *result != SCIP_CUTOFF /* a variable could not be branched in any direction or any of the calculated domain
                                   * reductions was infeasible */
          && *result != SCIP_REDUCEDDOM /* the domain of a variable was reduced by evaluating the calculated cutoffs */
-         && *result != SCIP_CONSADDED /* implied binary constraints were already added */
+         && *result != SCIP_CONSADDED /* implicit binary constraints were already added */
          && !status->depthtoosmall /* branching depth wasn't high enough */
          && branchingDecisionIsValid(decision)
          /*&& (0 <= bestcand && bestcand < nlpcands)*/ /* no valid candidate index could be found */

src/scip/cons_linear.c

@@ -14770,7 +14770,7 @@ SCIP_RETCODE fullDualPresolve(
    BMSclearMemoryArray(nlocksdown, nvars);
    BMSclearMemoryArray(nlocksup, nvars);
 
-   /* Initialize isimplint array: variable may be implied integer if rounded to their best bound they are integral.
+   /* Initialize isimplint array: variable may be implicit integer if rounded to their best bound they are integral.
     * We better not use SCIPisFeasIntegral() in these checks.
     */
    for( v = 0; v < ncontvars; v++ )
@@ -14972,13 +14972,13 @@ SCIP_RETCODE fullDualPresolve(
             }
          }
 
-         /* update implied integer status of continuous variables */
+         /* update implicit integer status of continuous variables */
          if( hasimpliedpotential )
          {
             if( nconscontvars > 1 || !integralcoefs )
             {
                /* there is more than one continuous variable or the integer variables have fractional coefficients:
-                * none of the continuous variables is implied integer
+                * none of the continuous variables is implicit integer
                 */
                for( i = 0; i < nconscontvars; i++ )
                {
@@ -15101,7 +15101,7 @@ SCIP_RETCODE fullDualPresolve(
       }
    }
 
-   /* upgrade continuous variables to implied integers */
+   /* upgrade continuous variables to implicit integers */
    for( v = nintvars - nbinvars; v < nvars; ++v )
    {
       SCIP_VAR* var;
@@ -15115,7 +15115,7 @@ SCIP_RETCODE fullDualPresolve(
       assert(SCIPvarGetNLocksUpType(var, SCIP_LOCKTYPE_MODEL) >= nlocksup[v]);
       assert(0 <= v - nintvars + nbinvars && v - nintvars + nbinvars < ncontvars);
 
-      /* we can only conclude implied integrality if the variable appears in no other constraint */
+      /* we can only conclude implicit integrality if the variable appears in no other constraint */
       if( isimplint[v - nintvars + nbinvars]
          && SCIPvarGetNLocksDownType(var, SCIP_LOCKTYPE_MODEL) == nlocksdown[v]
          && SCIPvarGetNLocksUpType(var, SCIP_LOCKTYPE_MODEL) == nlocksup[v] )

src/scip/cons_logicor.c

@@ -3081,7 +3081,7 @@ SCIP_RETCODE removeRedundantConssAndNonzeros(
     *        representation
     */
 
-   /* get number of all possible(incl. implcit) binary variables and their negation */
+   /* get number of all possible(incl. implicit) binary variables and their negation */
    nbinvars = SCIPgetNVars(scip) - SCIPgetNContVars(scip);
    occurlistsize = 2 * nbinvars;
 

src/scip/presol_dualsparsify.c

@@ -879,7 +879,7 @@ SCIP_RETCODE cancelCol(
                if( SCIPvarIsIntegral(cancelvar) )
                {
                   /* skip if the hashing variable is an integer variable and
-                   * the canceled variable is an implied integer variable
+                   * the canceled variable is an implicit integer variable
                    */
                   if( (SCIPvarGetType(hashingcolvar) != SCIP_VARTYPE_IMPLINT) &&
                      (SCIPvarGetType(cancelvar) == SCIP_VARTYPE_IMPLINT) )

src/scip/presol_implics.c

@@ -167,7 +167,7 @@ SCIP_DECL_PRESOLEXEC(presolExecImplics)
             }
             index1 = SCIPvarGetIndex(implvars[1][i1]); /*lint !e838*/
          }
-         /**@todo for all implied binary variables y, check the cliques of x == !varfixing if y is contained */
+         /**@todo for all implicit binary variables y, check the cliques of x == !varfixing if y is contained */
 
          if( index0 == index1 )
          {

src/scip/presolve.c

@@ -1094,7 +1094,7 @@ SCIP_RETCODE SCIPshrinkDisjunctiveVarSet(
       issetvar[varidx] = v+1;
    }
 
-   /* check if implied binary variables exist, because for these variables the implications can be stored in the
+   /* check if implicit binary variables exist, because for these variables the implications can be stored in the
     * variable bounds instead of the 'normal' implications
     */
    implbinvarsexist = (SCIPprobGetNImplBinVars(scip->transprob) > 0);
@@ -1109,7 +1109,7 @@ SCIP_RETCODE SCIPshrinkDisjunctiveVarSet(
    }
 #endif
 
-   /* check for same implied binary variables */
+   /* check for same implicit binary variables */
    for( v = 0; v < nvars; ++v )
    {
       var =  vars[v];
@@ -1278,7 +1278,7 @@ SCIP_RETCODE SCIPshrinkDisjunctiveVarSet(
 
       assert(start < nprobvars);
 
-      /* check for same implied binary variables */
+      /* check for same implicit binary variables */
       for( v = start; v < nprobvars; ++v )
       {
          probvar = probvars[v];

src/scip/sepa_mixing.c

@@ -107,14 +107,14 @@
 #define SEPA_DELAY                FALSE /**< should separation method be delayed, if other separators found cuts? */
 
 #define DEFAULT_USELOCALBOUNDS    FALSE /**< should local bounds be used? */
-#define DEFAULT_ISCUTSONINTS      FALSE /**< should general/implied integer variables be used to generate cuts? */
+#define DEFAULT_ISCUTSONINTS      FALSE /**< should general/implicit integer variables be used to generate cuts? */
 #define DEFAULT_MAXNUNSUCCESSFUL     10 /**< maximal number of consecutive unsuccessful iterations */
 
 /** separator-specific data for the mixing separator */
 struct SCIP_SepaData
 {
    SCIP_Bool             uselocalbounds;     /**< should local bounds be used? */
-   SCIP_Bool             iscutsonints;       /**< should general/implied integer variables be used to generate cuts? */
+   SCIP_Bool             iscutsonints;       /**< should general/implicit integer variables be used to generate cuts? */
    int                   maxrounds;          /**< maximal number of mixing separation rounds per node (-1: unlimited) */
    int                   maxroundsroot;      /**< maximal number of mixing separation rounds in the root node (-1: unlimited) */
    int                   nunsuccessful;      /**< number of consecutive unsuccessful iterations */