cons_linear.c
Go to the documentation of this file.
27 * @brief Constraint handler for linear constraints in their most general form, \f$lhs <= a^T x <= rhs\f$.
57 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
99 #define CONSHDLR_ENFOPRIORITY -1000000 /**< priority of the constraint handler for constraint enforcing */
100 #define CONSHDLR_CHECKPRIORITY -1000000 /**< priority of the constraint handler for checking feasibility */
101 #define CONSHDLR_SEPAFREQ 0 /**< frequency for separating cuts; zero means to separate only in the root node */
102 #define CONSHDLR_PROPFREQ 1 /**< frequency for propagating domains; zero means only preprocessing propagation */
103 #define CONSHDLR_EAGERFREQ 100 /**< frequency for using all instead of only the useful constraints in separation,
105 #define CONSHDLR_MAXPREROUNDS -1 /**< maximal number of presolving rounds the constraint handler participates in (-1: no limit) */
106 #define CONSHDLR_DELAYSEPA FALSE /**< should separation method be delayed, if other separators found cuts? */
107 #define CONSHDLR_DELAYPROP FALSE /**< should propagation method be delayed, if other propagators found reductions? */
108 #define CONSHDLR_NEEDSCONS TRUE /**< should the constraint handler be skipped, if no constraints are available? */
110 #define CONSHDLR_PRESOLTIMING (SCIP_PRESOLTIMING_FAST | SCIP_PRESOLTIMING_EXHAUSTIVE) /**< presolving timing of the constraint handler (fast, medium, or exhaustive) */
120 #define DEFAULT_TIGHTENBOUNDSFREQ 1 /**< multiplier on propagation frequency, how often the bounds are tightened */
121 #define DEFAULT_MAXROUNDS 5 /**< maximal number of separation rounds per node (-1: unlimited) */
122 #define DEFAULT_MAXROUNDSROOT -1 /**< maximal number of separation rounds in the root node (-1: unlimited) */
124 #define DEFAULT_MAXSEPACUTSROOT 200 /**< maximal number of cuts separated per separation round in root node */
125 #define DEFAULT_PRESOLPAIRWISE TRUE /**< should pairwise constraint comparison be performed in presolving? */
126 #define DEFAULT_PRESOLUSEHASHING TRUE /**< should hash table be used for detecting redundant constraints in advance */
127 #define DEFAULT_NMINCOMPARISONS 200000 /**< number for minimal pairwise presolving comparisons */
128 #define DEFAULT_MINGAINPERNMINCOMP 1e-06 /**< minimal gain per minimal pairwise presolving comparisons to repeat pairwise
130 #define DEFAULT_SORTVARS TRUE /**< should variables be sorted after presolve w.r.t their coefficient absolute for faster
132 #define DEFAULT_CHECKRELMAXABS FALSE /**< should the violation for a constraint with side 0.0 be checked relative
134 #define DEFAULT_MAXAGGRNORMSCALE 0.0 /**< maximal allowed relative gain in maximum norm for constraint aggregation
136 #define DEFAULT_MAXEASYACTIVITYDELTA 1e6 /**< maximum activity delta to run easy propagation on linear constraint
138 #define DEFAULT_MAXCARDBOUNDDIST 0.0 /**< maximal relative distance from current node's dual bound to primal bound compared
140 #define DEFAULT_SEPARATEALL FALSE /**< should all constraints be subject to cardinality cut generation instead of only
142 #define DEFAULT_AGGREGATEVARIABLES TRUE /**< should presolving search for redundant variables in equations */
143 #define DEFAULT_SIMPLIFYINEQUALITIES TRUE /**< should presolving try to simplify inequalities */
145 #define DEFAULT_SINGLETONSTUFFING TRUE /**< should stuffing of singleton continuous variables be performed? */
146 #define DEFAULT_SINGLEVARSTUFFING FALSE /**< should single variable stuffing be performed, which tries to fulfill
148 #define DEFAULT_DETECTCUTOFFBOUND TRUE /**< should presolving try to detect constraints parallel to the objective
151 #define DEFAULT_DETECTLOWERBOUND TRUE /**< should presolving try to detect constraints parallel to the objective
154 #define DEFAULT_DETECTPARTIALOBJECTIVE TRUE/**< should presolving try to detect subsets of constraints parallel to the
157 #define DEFAULT_RANGEDROWARTCONS TRUE /**< should presolving and propagation extract sub-constraints from ranged rows and equations? */
161 #define DEFAULT_MULTAGGRREMOVE FALSE /**< should multi-aggregations only be performed if the constraint can be
163 #define DEFAULT_MAXMULTAGGRQUOT 1e+03 /**< maximum coefficient dynamism (ie. maxabsval / minabsval) for multiaggregation */
164 #define DEFAULT_MAXDUALMULTAGGRQUOT 1e+20 /**< maximum coefficient dynamism (ie. maxabsval / minabsval) for multiaggregation */
169 #define MAXSCALEDCOEFINTEGER 0 /**< maximal coefficient value after scaling if all variables are of integral
176 #define MAXVALRECOMP 1e+06 /**< maximal abolsute value we trust without recomputing the activity */
177 #define MINVALRECOMP 1e-05 /**< minimal abolsute value we trust without recomputing the activity */
180 #define NONLINCONSUPGD_PRIORITY 1000000 /**< priority of the constraint handler for upgrading of expressions constraints */
182 /* @todo add multi-aggregation of variables that are in exactly two equations (, if not numerically an issue),
189 {
194 QUAD_MEMBER(SCIP_Real minactivity); /**< minimal value w.r.t. the variable's local bounds for the constraint's
196 QUAD_MEMBER(SCIP_Real maxactivity); /**< maximal value w.r.t. the variable's local bounds for the constraint's
202 QUAD_MEMBER(SCIP_Real glbminactivity); /**< minimal value w.r.t. the variable's global bounds for the constraint's
204 QUAD_MEMBER(SCIP_Real glbmaxactivity); /**< maximal value w.r.t. the variable's global bounds for the constraint's
206 SCIP_Real lastglbminactivity; /**< last global minimal activity which was computed by complete summation
208 SCIP_Real lastglbmaxactivity; /**< last global maximal activity which was computed by complete summation
210 SCIP_Real maxactdelta; /**< maximal activity contribution of a single variable, or SCIP_INVALID if invalid */
211 SCIP_VAR* maxactdeltavar; /**< variable with maximal activity contribution, or NULL if invalid */
219 int minactivityneginf; /**< number of coefficients contributing with neg. infinite value to minactivity */
220 int minactivityposinf; /**< number of coefficients contributing with pos. infinite value to minactivity */
221 int maxactivityneginf; /**< number of coefficients contributing with neg. infinite value to maxactivity */
222 int maxactivityposinf; /**< number of coefficients contributing with pos. infinite value to maxactivity */
223 int minactivityneghuge; /**< number of coefficients contributing with huge neg. value to minactivity */
224 int minactivityposhuge; /**< number of coefficients contributing with huge pos. value to minactivity */
225 int maxactivityneghuge; /**< number of coefficients contributing with huge neg. value to maxactivity */
226 int maxactivityposhuge; /**< number of coefficients contributing with huge pos. value to maxactivity */
227 int glbminactivityneginf;/**< number of coefficients contrib. with neg. infinite value to glbminactivity */
228 int glbminactivityposinf;/**< number of coefficients contrib. with pos. infinite value to glbminactivity */
229 int glbmaxactivityneginf;/**< number of coefficients contrib. with neg. infinite value to glbmaxactivity */
230 int glbmaxactivityposinf;/**< number of coefficients contrib. with pos. infinite value to glbmaxactivity */
231 int glbminactivityneghuge;/**< number of coefficients contrib. with huge neg. value to glbminactivity */
232 int glbminactivityposhuge;/**< number of coefficients contrib. with huge pos. value to glbminactivity */
233 int glbmaxactivityneghuge;/**< number of coefficients contrib. with huge neg. value to glbmaxactivity */
234 int glbmaxactivityposhuge;/**< number of coefficients contrib. with huge pos. value to glbmaxactivity */
241 unsigned int rangedrowpropagated:2; /**< did we perform ranged row propagation on this constraint?
253 unsigned int changed:1; /**< was constraint changed since last aggregation round in preprocessing? */
256 unsigned int upgraded:1; /**< is the constraint upgraded and will it be removed after preprocessing? */
261 unsigned int coefsorted:1; /**< are variables sorted by type and their absolute activity delta? */
263 unsigned int hascontvar:1; /**< does the constraint contain at least one continuous variable? */
264 unsigned int hasnonbinvar:1; /**< does the constraint contain at least one non-binary variable? */
265 unsigned int hasnonbinvalid:1; /**< is the information stored in hasnonbinvar and hascontvar valid? */
266 unsigned int checkabsolute:1; /**< should the constraint be checked w.r.t. an absolute feasibilty tolerance? */
281 SCIP_LINCONSUPGRADE** linconsupgrades; /**< linear constraint upgrade methods for specializing linear constraints */
282 SCIP_Real maxaggrnormscale; /**< maximal allowed relative gain in maximum norm for constraint aggregation
284 SCIP_Real maxcardbounddist; /**< maximal relative distance from current node's dual bound to primal bound compared
286 SCIP_Real mingainpernmincomp; /**< minimal gain per minimal pairwise presolving comparisons to repeat pairwise comparison round */
287 SCIP_Real maxeasyactivitydelta;/**< maximum activity delta to run easy propagation on linear constraint
291 int tightenboundsfreq; /**< multiplier on propagation frequency, how often the bounds are tightened */
298 SCIP_Bool presolpairwise; /**< should pairwise constraint comparison be performed in presolving? */
299 SCIP_Bool presolusehashing; /**< should hash table be used for detecting redundant constraints in advance */
300 SCIP_Bool separateall; /**< should all constraints be subject to cardinality cut generation instead of only
302 SCIP_Bool aggregatevariables; /**< should presolving search for redundant variables in equations */
303 SCIP_Bool simplifyinequalities;/**< should presolving try to cancel down or delete coefficients in inequalities */
305 SCIP_Bool singletonstuffing; /**< should stuffing of singleton continuous variables be performed? */
306 SCIP_Bool singlevarstuffing; /**< should single variable stuffing be performed, which tries to fulfill
309 SCIP_Bool checkrelmaxabs; /**< should the violation for a constraint with side 0.0 be checked relative
311 SCIP_Bool detectcutoffbound; /**< should presolving try to detect constraints parallel to the objective
314 SCIP_Bool detectlowerbound; /**< should presolving try to detect constraints parallel to the objective
317 SCIP_Bool detectpartialobjective;/**< should presolving try to detect subsets of constraints parallel to
319 SCIP_Bool rangedrowpropagation;/**< should presolving and propagation try to improve bounds, detect
322 SCIP_Bool rangedrowartcons; /**< should presolving and propagation extract sub-constraints from ranged rows and equations?*/
325 SCIP_Bool multaggrremove; /**< should multi-aggregations only be performed if the constraint can be
327 SCIP_Real maxmultaggrquot; /**< maximum coefficient dynamism (ie. maxabsval / minabsval) for primal multiaggregation */
328 SCIP_Real maxdualmultaggrquot;/**< maximum coefficient dynamism (ie. maxabsval / minabsval) for dual multiaggregation */
351 PROPRULE_1_RANGEDROW = 3, /**< fixed variables and gcd of all left variables tighten bounds of a
366 } asbits;
368 } val;
389 )
431 /** constructs an inference information out of a propagation rule and a position number, returns info as int */
452 )
463 SCIP_CALL( SCIPreallocBlockMemoryArray(scip, &conshdlrdata->linconsupgrades, conshdlrdata->linconsupgradessize, newsize) );
492 SCIP_CALL( SCIPreallocBlockMemoryArray(scip, &consdata->eventdata, consdata->varssize, newsize) );
548 {
582 SCIPfreeBlockMemoryArrayNull(scip, &(*conshdlrdata)->linconsupgrades, (*conshdlrdata)->linconsupgradessize);
608 SCIPwarningMessage(scip, "Try to add already known upgrade message for constraint handler %s.\n", conshdlrname);
631 SCIP_CALL( conshdlrdataEnsureLinconsupgradesSize(scip, conshdlrdata, conshdlrdata->nlinconsupgrades+1) );
638 assert(0 <= i && i <= conshdlrdata->nlinconsupgrades);
649 /** installs rounding locks for the given variable associated to the given coefficient in the linear constraint */
682 /** removes rounding locks for the given variable associated to the given coefficient in the linear constraint */
776 assert(consdata->eventdata[pos]->cons == cons);
924 if( SCIPisConsCompressionEnabled(scip) && SCIPisEQ(scip, SCIPvarGetLbGlobal(var), SCIPvarGetUbGlobal(var)) )
966 /* due to compressed copying, we may have fixed variables contributing to the left and right hand side */
1038 SCIP_CALL( SCIPgetTransformedVars(scip, (*consdata)->nvars, (*consdata)->vars, (*consdata)->vars) );
1122 {
1124 SCIP_CALL( SCIPwriteVarsLinearsum(scip, file, consdata->vars, consdata->vals, consdata->nvars, TRUE) );
1157 SCIPmessageFPrintInfo(SCIPgetMessagehdlr(scip), file, " [%s] <%s>: ", SCIPconshdlrGetName(SCIPconsGetHdlr(cons)), SCIPconsGetName(cons));
1279 bound = (SCIPvarGetBestBoundType(consdata->vars[i]) == SCIP_BOUNDTYPE_LOWER) ? SCIPvarGetLbLocal(consdata->vars[i]) : SCIPvarGetUbLocal(consdata->vars[i]);
1325 bound = (consdata->vals[i] > 0.0 ) ? SCIPvarGetLbLocal(consdata->vars[i]) : SCIPvarGetUbLocal(consdata->vars[i]);
1327 && !SCIPisHugeValue(scip, consdata->vals[i] * bound) && !SCIPisHugeValue(scip, -consdata->vals[i] * bound) )
1352 bound = (consdata->vals[i] > 0.0 ) ? SCIPvarGetUbLocal(consdata->vars[i]) : SCIPvarGetLbLocal(consdata->vars[i]);
1354 && !SCIPisHugeValue(scip, consdata->vals[i] * bound) && !SCIPisHugeValue(scip, -consdata->vals[i] * bound) )
1379 bound = (consdata->vals[i] > 0.0 ) ? SCIPvarGetLbGlobal(consdata->vars[i]) : SCIPvarGetUbGlobal(consdata->vars[i]);
1381 && !SCIPisHugeValue(scip, consdata->vals[i] * bound) && !SCIPisHugeValue(scip, -consdata->vals[i] * bound) )
1382 SCIPquadprecSumQD(consdata->glbminactivity, consdata->glbminactivity, consdata->vals[i] * bound);
1406 bound = (consdata->vals[i] > 0.0 ) ? SCIPvarGetUbGlobal(consdata->vars[i]) : SCIPvarGetLbGlobal(consdata->vars[i]);
1408 && !SCIPisHugeValue(scip, consdata->vals[i] * bound) && !SCIPisHugeValue(scip, -consdata->vals[i] * bound) )
1409 SCIPquadprecSumQD(consdata->glbmaxactivity, consdata->glbmaxactivity, consdata->vals[i] * bound);
1440 }
1464 {
1472 /** checks the type of all variables of the constraint and sets hasnonbinvar and hascontvar flags accordingly */
1493 {
1569 {
1621 SCIP_Bool checkreliability /**< should the reliability of the recalculated activity be checked? */
1673 * lower bound + neg. coef: update maxactivity, positive and negative infinity counters have to be switched
1675 * upper bound + neg. coef: update minactivity, positive and negative infinity counters have to be switched
1729 * lower bound + neg. coef: update maxactivity, positive and negative infinity counters have to be switched
1731 * upper bound + neg. coef: update minactivity, positive and negative infinity counters have to be switched
1799 /* if the bound changed to -infinity, increase the counter for negative infinite contributions */
1827 /* if the bound changed to +infinity, increase the counter for positive infinite contributions */
1852 * but checking here that the bound is not huge again would not handle a change from a huge to an infinite bound
1858 /* if the bound changed to +infinity, increase the counter for positive infinite contributions */
1861 /* if the bound changed to -infinity, increase the counter for negative infinite contributions */
1867 /* if the contribution of this variable is too large and positive, increase the corresponding counter */
1870 /* if the contribution of this variable is too large and negative, increase the corresponding counter */
1885 * but checking here that the bound is not huge again would not handle a change from a huge to an infinite bound
1891 /* if the bound changed to +infinity, increase the counter for positive infinite contributions */
1894 /* if the bound changed to -infinity, increase the counter for negative infinite contributions */
1900 /* if the contribution of this variable is too large and positive, increase the corresponding counter */
1903 /* if the contribution of this variable is too large and negative, increase the corresponding counter */
1958 /* update the activity, if the current value is valid and there was a change in the finite part */
2011 SCIP_Bool checkreliability /**< should the reliability of the recalculated activity be checked? */
2020 consdataUpdateActivities(scip, consdata, var, oldlb, newlb, val, SCIP_BOUNDTYPE_LOWER, FALSE, checkreliability);
2022 assert(!SCIPisInfinity(scip, -QUAD_TO_DBL(consdata->minactivity)) && !SCIPisInfinity(scip, QUAD_TO_DBL(consdata->minactivity)));
2023 assert(!SCIPisInfinity(scip, -QUAD_TO_DBL(consdata->maxactivity)) && !SCIPisInfinity(scip, QUAD_TO_DBL(consdata->maxactivity)));
2036 SCIP_Bool checkreliability /**< should the reliability of the recalculated activity be checked? */
2045 consdataUpdateActivities(scip, consdata, var, oldub, newub, val, SCIP_BOUNDTYPE_UPPER, FALSE, checkreliability);
2047 assert(!SCIPisInfinity(scip, -QUAD_TO_DBL(consdata->minactivity)) && !SCIPisInfinity(scip, QUAD_TO_DBL(consdata->minactivity)));
2048 assert(!SCIPisInfinity(scip, -QUAD_TO_DBL(consdata->maxactivity)) && !SCIPisInfinity(scip, QUAD_TO_DBL(consdata->maxactivity)));
2060 SCIP_Bool checkreliability /**< should the reliability of the recalculated activity be checked? */
2068 consdataUpdateActivities(scip, consdata, NULL, oldlb, newlb, val, SCIP_BOUNDTYPE_LOWER, TRUE, checkreliability);
2070 assert(!SCIPisInfinity(scip, -QUAD_TO_DBL(consdata->glbminactivity)) && !SCIPisInfinity(scip, QUAD_TO_DBL(consdata->glbminactivity)));
2071 assert(!SCIPisInfinity(scip, -QUAD_TO_DBL(consdata->glbmaxactivity)) && !SCIPisInfinity(scip, QUAD_TO_DBL(consdata->glbmaxactivity)));
2073 }
2083 SCIP_Bool checkreliability /**< should the reliability of the recalculated activity be checked? */
2091 consdataUpdateActivities(scip, consdata, NULL, oldub, newub, val, SCIP_BOUNDTYPE_UPPER, TRUE, checkreliability);
2093 assert(!SCIPisInfinity(scip, -QUAD_TO_DBL(consdata->glbminactivity)) && !SCIPisInfinity(scip, QUAD_TO_DBL(consdata->glbminactivity)));
2094 assert(!SCIPisInfinity(scip, -QUAD_TO_DBL(consdata->glbmaxactivity)) && !SCIPisInfinity(scip, QUAD_TO_DBL(consdata->glbmaxactivity)));
2096 }
2098 /** updates minimum and maximum activity and maximum absolute value for coefficient addition */
2105 SCIP_Bool checkreliability /**< should the reliability of the recalculated activity be checked? */
2141 consdataUpdateActivitiesLb(scip, consdata, var, 0.0, SCIPvarGetLbLocal(var), val, checkreliability);
2142 consdataUpdateActivitiesUb(scip, consdata, var, 0.0, SCIPvarGetUbLocal(var), val, checkreliability);
2143 consdataUpdateActivitiesGlbLb(scip, consdata, 0.0, SCIPvarGetLbGlobal(var), val, checkreliability);
2144 consdataUpdateActivitiesGlbUb(scip, consdata, 0.0, SCIPvarGetUbGlobal(var), val, checkreliability);
2148 /** updates minimum and maximum activity for coefficient deletion, invalidates maximum absolute value if necessary */
2155 SCIP_Bool checkreliability /**< should the reliability of the recalculated activity be checked? */
2198 consdataUpdateActivitiesLb(scip, consdata, var, SCIPvarGetLbLocal(var), 0.0, val, checkreliability);
2199 consdataUpdateActivitiesUb(scip, consdata, var, SCIPvarGetUbLocal(var), 0.0, val, checkreliability);
2200 consdataUpdateActivitiesGlbLb(scip, consdata, SCIPvarGetLbGlobal(var), 0.0, val, checkreliability);
2201 consdataUpdateActivitiesGlbUb(scip, consdata, SCIPvarGetUbGlobal(var), 0.0, val, checkreliability);
2205 /** updates minimum and maximum activity for coefficient change, invalidates maximum absolute value if necessary */
2213 SCIP_Bool checkreliability /**< should the reliability of the recalculated activity be checked? */
2293 /* reset maximal activity delta, so that it will be recalculated on the next real propagation */
2299 /* @todo do something more clever here, e.g. if oldval * newval >= 0, do the update directly */
2325 {
2398 /** gets minimal activity for constraint and given values of counters for infinite and huge contributions
2399 * and (if needed) delta to subtract from stored finite part of activity in case of a residual activity
2412 SCIP_Bool goodrelax, /**< should a good relaxation be computed or are relaxed acticities ignored, anyway? */
2416 SCIP_Bool* issettoinfinity /**< pointer to store whether minactivity was set to infinity or calculated */
2421 assert(posinf >= 0);
2443 /* if we have neg. huge contributions, we only know that -infty is a relaxation of the minactivity */
2450 /* we do not need a good relaxation and we have positive huge contributions, so we just return -infty as activity */
2481 * times the minimum value counting as "huge" plus finite (and non-huge) part of minactivity - delta
2499 /** gets maximal activity for constraint and given values of counters for infinite and huge contributions
2500 * and (if needed) delta to subtract from stored finite part of activity in case of a residual activity
2513 SCIP_Bool goodrelax, /**< should a good relaxation be computed or are relaxed acticities ignored, anyway? */
2517 SCIP_Bool* issettoinfinity /**< pointer to store whether maxactivity was set to infinity or calculated */
2522 assert(posinf >= 0);
2544 /* if we have pos. huge contributions, we only know that +infty is a relaxation of the maxactivity */
2551 /* we do not need a good relaxation and we have positve huge contributions, so we just return +infty as activity */
2582 * times the minimum value counting as "huge" plus the finite (and non-huge) part of maxactivity minus delta
2609 SCIP_Bool* minisrelax, /**< pointer to store whether the returned minactivity is just a relaxation,
2612 SCIP_Bool* maxisrelax, /**< pointer to store whether the returned maxactivity is just a relaxation,
2615 SCIP_Bool* isminsettoinfinity, /**< pointer to store whether minactivity was set to infinity or calculated */
2616 SCIP_Bool* ismaxsettoinfinity /**< pointer to store whether maxactivity was set to infinity or calculated */
2741 SCIP_Bool* minisrelax, /**< pointer to store whether the returned residual minactivity is just a
2744 SCIP_Bool* maxisrelax, /**< pointer to store whether the returned residual maxactivity is just a
2747 SCIP_Bool* isminsettoinfinity, /**< pointer to store whether minresactivity was set to infinity or calculated */
2748 SCIP_Bool* ismaxsettoinfinity /**< pointer to store whether maxresactivity was set to infinity or calculated */
2796 /* get/compute minactivity by calling getMinActivity() with updated counters for infinite and huge values
2797 * and contribution of variable set to zero that has to be subtracted from finite part of activity
2834 consdata->minactivityposhuge, consdata->minactivityneghuge, absval * minactbound, FALSE, goodrelax,
2838 /* get/compute maxactivity by calling getMaxActivity() with updated counters for infinite and huge values
2839 * and contribution of variable set to zero that has to be subtracted from finite part of activity
2876 consdata->maxactivityposhuge, consdata->maxactivityneghuge, absval * maxactbound, FALSE, goodrelax,
2888 SCIP_Real* glbminactivity, /**< pointer to store the minimal activity, or NULL, if not needed */
2889 SCIP_Real* glbmaxactivity, /**< pointer to store the maximal activity, or NULL, if not needed */
2890 SCIP_Bool* minisrelax, /**< pointer to store whether the returned minactivity is just a relaxation,
2893 SCIP_Bool* maxisrelax, /**< pointer to store whether the returned maxactivity is just a relaxation,
2896 SCIP_Bool* isminsettoinfinity, /**< pointer to store whether minresactivity was set to infinity or calculated */
2897 SCIP_Bool* ismaxsettoinfinity /**< pointer to store whether maxresactivity was set to infinity or calculated */
2952 SCIP_Real* minresactivity, /**< pointer to store the minimal residual activity, or NULL, if not needed */
2953 SCIP_Real* maxresactivity, /**< pointer to store the maximal residual activity, or NULL, if not needed */
2954 SCIP_Bool* minisrelax, /**< pointer to store whether the returned residual minactivity is just a
2957 SCIP_Bool* maxisrelax, /**< pointer to store whether the returned residual maxactivity is just a
2960 SCIP_Bool* isminsettoinfinity, /**< pointer to store whether minresactivity was set to infinity or calculated */
2961 SCIP_Bool* ismaxsettoinfinity /**< pointer to store whether maxresactivity was set to infinity or calculated */
3003 /* get/compute minactivity by calling getMinActivity() with updated counters for infinite and huge values
3004 * and contribution of variable set to zero that has to be subtracted from finite part of activity
3010 getMinActivity(scip, consdata, consdata->glbminactivityposinf - 1, consdata->glbminactivityneginf,
3018 getMinActivity(scip, consdata, consdata->glbminactivityposinf, consdata->glbminactivityneginf - 1,
3051 /* get/compute maxactivity by calling getMaxActivity() with updated counters for infinite and huge values
3052 * and contribution of variable set to zero that has to be subtracted from finite part of activity
3058 getMaxActivity(scip, consdata, consdata->glbmaxactivityposinf, consdata->glbmaxactivityneginf - 1,
3066 getMaxActivity(scip, consdata, consdata->glbmaxactivityposinf - 1, consdata->glbmaxactivityneginf,
3133 else if( (SCIPisInfinity(scip, solval) && negsign) || (SCIPisInfinity(scip, -solval) && !negsign) )
3140 SCIPdebugMsg(scip, "activity of linear constraint: %.15g, %d positive infinity values, %d negative infinity values \n", activity, nposinf, nneginf);
3229 /** index comparison method of linear constraints: compares two indices of the variable set in the linear constraint */
3268 /** index comparison method of linear constraints: compares two indices of the variable set in the linear constraint */
3324 SCIP_Real abscont1 = REALABS(consdata->vals[ind1] * (SCIPvarGetUbGlobal(var1) - SCIPvarGetLbGlobal(var1)));
3325 SCIP_Real abscont2 = REALABS(consdata->vals[ind2] * (SCIPvarGetUbGlobal(var2) - SCIPvarGetLbGlobal(var2)));
3359 {
3409 * sorts variables of the remaining problem by binaries, integers, implicit integers, and continuous variables,
3530 /* the left hand side switched from -infinity to a non-infinite value -> install rounding locks */
3555 /* the left hand side switched from a non-infinite value to -infinity -> remove rounding locks */
3576 /* check whether the left hand side is increased, if and only if that's the case we maybe can propagate, tighten and add more cliques */
3658 /* the right hand side switched from infinity to a non-infinite value -> install rounding locks */
3683 /* the right hand side switched from a non-infinite value to infinity -> remove rounding locks */
3704 /* check whether the right hand side is decreased, if and only if that's the case we maybe can propagate, tighten and add more cliques */
3752 assert(!SCIPvarIsRelaxationOnly(var) || (!SCIPconsIsChecked(cons) && !SCIPconsIsEnforced(cons)));
3867 consdata->indexsorted = consdata->indexsorted && (consdataCompVar((void*)consdata, consdata->nvars-2, consdata->nvars-1) <= 0);
3873 consdata->coefsorted = consdata->coefsorted && (consdataCompVarProp((void*)consdata, consdata->nvars-2, consdata->nvars-1) <= 0);
3964 /* if at most one variable is left, the activities should be recalculated (to correspond exactly to the bounds
3976 /* if the variable defining the maximal activity delta was removed from the constraint, the maximal activity
4042 assert(0 <= pos && pos < consdata->nvars);
4124 SCIPwarningMessage(scip, "skipped scaling for linear constraint <%s> to avoid numerical troubles (scalar: %.15g)\n",
4135 /* because SCIPisScalingIntegral uses another integrality check as SCIPfeasFloor, we add an additional 0.5 before
4143 SCIPwarningMessage(scip, "coefficient %.15g of variable <%s> in linear constraint <%s> scaled to zero (scalar: %.15g)\n",
4165 /* because SCIPisScalingIntegral uses another integrality check as SCIPfeasFloor, we add an additional 0.5 before
4177 /* because SCIPisScalingIntegral uses another integrality check as SCIPfeasCeil, we subtract 0.5 before ceiling up
4214 {
4239 * Apply the following rules in the given order, until the sign of the factor is determined. Later rules only apply,
4244 * 4. the number of positive coefficients must not be smaller than the number of negative coefficients
4247 * Try to identify a rational representation of the fractional coefficients, and multiply all coefficients
4329 SCIPdebugMsg(scip, "divide linear constraint with %g, because all coefficients are in absolute value the same\n", maxabsval);
4356 epsilon = SCIPepsilon(scip) * 0.9; /* slightly decrease epsilon to be safe in rational conversion below */
4368 maxmult = MIN(maxmult, (SCIP_Longint) (MAXSCALEDCOEFINTEGER / MAX(maxabsval, 1.0))); /*lint !e835*/
4394 /* 3. the absolute value of the right hand side must be greater than that of the left hand side */
4403 /* 4. the number of positive coefficients must not be smaller than the number of negative coefficients */
4456 /* it might be that we have really big coefficients, but all are integral, in that case we want to divide them by
4476 SCIPdebugMsg(scip, "scale linear constraint with %" SCIP_LONGINT_FORMAT " to make coefficients integral\n", scm);
4525 /* since the lhs/rhs is not respected for gcd calculation it can happen that we detect infeasibility */
4528 if( SCIPisEQ(scip, consdata->lhs, consdata->rhs) && !SCIPisFeasIntegral(scip, consdata->rhs / gcd) )
4532 SCIPdebugMsg(scip, "detected infeasibility of constraint after scaling with gcd=%" SCIP_LONGINT_FORMAT ":\n", gcd);
4540 SCIPdebugMsg(scip, "divide linear constraint by greatest common divisor %" SCIP_LONGINT_FORMAT "\n", gcd);
4613 /* if the variable defining the maximal activity delta was removed from the constraint, the maximal activity
4686 /* if an unmodifiable row has been added to the LP, then we cannot apply fixing anymore (cannot change a row)
4687 * this should not happen, as applyFixings is called in addRelaxation() before creating and adding a row
4689 assert(consdata->row == NULL || !SCIProwIsInLP(consdata->row) || SCIProwIsModifiable(consdata->row));
4842 if( SCIPisEQ(scip, lhssubtrahend, consdata->lhs) && SCIPisFeasGE(scip, REALABS(lhssubtrahend), 1.0) )
4858 if( SCIPisEQ(scip, rhssubtrahend, consdata->rhs ) && SCIPisFeasGE(scip, REALABS(rhssubtrahend), 1.0) )
4872 /* if aggregated variables have been replaced, multiple entries of the same variable are possible and we have
4891 /** for each variable in the linear constraint, except the inferred variable, adds one bound to the conflict analysis'
4892 * candidate store (bound depends on sign of coefficient and whether the left or right hand side was the reason for the
4893 * inference variable's bound change); the conflict analysis can be initialized with the linear constraint being the
4901 SCIP_BDCHGIDX* bdchgidx, /**< bound change index (time stamp of bound change), or NULL for current time */
4930 /* for each variable, add the bound to the conflict queue, that is responsible for the minimal or maximal
4931 * residual value, depending on whether the left or right hand side is responsible for the bound change:
4936 /* if the variable is integral we only need to add reason bounds until the propagation could be applied */
4949 /* calculate the minimal and maximal global activity of all other variables involved in the constraint */
4954 consdataGetGlbActivityResiduals(scip, consdata, infervar, vals[inferpos], FALSE, &minresactivity, NULL,
4957 consdataGetGlbActivityResiduals(scip, consdata, infervar, vals[inferpos], FALSE, NULL, &maxresactivity,
4971 if( (reasonisrhs && !isminsettoinfinity && !minisrelax) || (!reasonisrhs && !ismaxsettoinfinity && !maxisrelax) ) /*lint !e644*/
4978 /* calculate the residual capacity that would be left, if the variable would be set to one more / one less
5033 /* rhs is reason and coeff is positive, or lhs is reason and coeff is negative -> lower bound */
5035 rescap -= vals[i] * (SCIPgetVarLbAtIndex(scip, vars[i], bdchgidx, FALSE) - SCIPvarGetLbGlobal(vars[i]));
5039 /* lhs is reason and coeff is positive, or rhs is reason and coeff is negative -> upper bound */
5041 rescap -= vals[i] * (SCIPgetVarUbAtIndex(scip, vars[i], bdchgidx, FALSE) - SCIPvarGetUbGlobal(vars[i]));
5061 /* rhs is reason and coeff is positive, or lhs is reason and coeff is negative -> lower bound is responsible */
5066 /* lhs is reason and coeff is positive, or rhs is reason and coeff is negative -> upper bound is responsible */
5074 /** for each variable in the linear ranged row constraint, except the inferred variable, adds the bounds of all fixed
5075 * variables to the conflict analysis' candidate store; the conflict analysis can be initialized
5076 * with the linear constraint being the conflict detecting constraint by using NULL as inferred variable
5083 SCIP_BDCHGIDX* bdchgidx, /**< bound change index (time stamp of bound change), or NULL for current time */
5098 nvars = consdata->nvars;
5115 if( !SCIPisEQ(scip, SCIPgetVarLbAtIndex(scip, vars[v], bdchgidx, FALSE), SCIPvarGetLbGlobal(vars[v])) )
5121 if( !SCIPisEQ(scip, SCIPgetVarUbAtIndex(scip, vars[v], bdchgidx, FALSE), SCIPvarGetUbGlobal(vars[v])) )
5131 if( SCIPisEQ(scip, SCIPgetVarLbAtIndex(scip, vars[v], bdchgidx, FALSE), SCIPgetVarUbAtIndex(scip, vars[v], bdchgidx, FALSE)) )
5133 /* add all bounds of fixed variables which lead to the boundchange of the given inference variable */
5163 {
5190 /** resolves a propagation on the given variable by supplying the variables needed for applying the corresponding
5201 SCIP_BDCHGIDX* bdchgidx, /**< bound change index (time stamp of bound change), or NULL for current time */
5202 SCIP_RESULT* result /**< pointer to store the result of the propagation conflict resolving call */
5243 /* the bound of the variable was tightened, because the minimal or maximal residual activity of the linear
5244 * constraint (only taking the other variables into account) didn't leave enough space for a larger
5253 /* the bound of the variable was tightened, because the minimal or maximal residual activity of the linear
5254 * constraint (only taking the other variables into account) didn't leave enough space for a larger
5263 /* the bound of the variable was tightened, because some variables were already fixed and the leftover only allow
5275 SCIPerrorMessage("invalid inference information %d in linear constraint <%s> at position %d for %s bound of variable <%s>\n",
5286 /** analyzes conflicting bounds on given constraint, and adds conflict constraint to problem */
5295 if( (SCIPgetStage(scip) != SCIP_STAGE_SOLVING && !SCIPinProbing(scip)) || !SCIPisConflictAnalysisApplicable(scip) )
5301 /* add the conflicting bound for each variable of infeasible constraint to conflict candidate queue */
5349 SCIP_Bool force /**< should a possible bound change be forced even if below bound strengthening tolerance */
5373 SCIPdebugMsg(scip, "linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, activity=[%.15g,%.15g], sides=[%.15g,%.15g] -> newub=%.15g\n",
5375 QUAD_TO_DBL(consdata->minactivity), QUAD_TO_DBL(consdata->maxactivity), consdata->lhs, consdata->rhs, newub);
5380 SCIP_CALL( SCIPinferVarUbCons(scip, var, newub, cons, getInferInt(proprule, pos), force, &infeasible, &tightened) );
5419 SCIP_Bool force /**< should a possible bound change be forced even if below bound strengthening tolerance */
5443 SCIPdebugMsg(scip, "linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, activity=[%.15g,%.15g], sides=[%.15g,%.15g] -> newlb=%.15g\n",
5445 QUAD_TO_DBL(consdata->minactivity), QUAD_TO_DBL(consdata->maxactivity), consdata->lhs, consdata->rhs, newlb);
5450 SCIP_CALL( SCIPinferVarLbCons(scip, var, newlb, cons, getInferInt(proprule, pos), force, &infeasible, &tightened) );
5486 SCIP_Bool force /**< should a possible bound change be forced even if below bound strengthening tolerance */
5546 /* min activity should be valid at this point (if this is not true, then some decisions might be wrong!) */
5549 /* if the minactivity is larger than the right hand side by feasibility epsilon, the constraint is infeasible */
5561 /* if the slack is zero in tolerances (or negative, but not enough to make the constraint infeasible), we set
5605 /* if the maxactivity is smaller than the left hand side by feasibility epsilon, the constraint is infeasible */
5617 /* if the slack is zero in tolerances (or negative, but not enough to make the constraint infeasible), we set
5653 /* min activity should be valid at this point (if this is not true, then some decisions might be wrong!) */
5656 /* if the minactivity is larger than the right hand side by feasibility epsilon, the constraint is infeasible */
5668 /* if the slack is zero in tolerances (or negative, but not enough to make the constraint infeasible), we set
5711 /* if the maxactivity is smaller than the left hand side by feasibility epsilon, the constraint is infeasible */
5723 /* if the slack is zero in tolerances (or negative, but not enough to make the constraint infeasible), we set
5755 /** analyzes conflicting bounds on given ranged row constraint, and adds conflict constraint to problem */
5778 if( (SCIPgetStage(scip) != SCIP_STAGE_SOLVING && !SCIPinProbing(scip)) || !SCIPisConflictAnalysisApplicable(scip) )
5784 /* add the conflicting fixed variables of this ranged row constraint to conflict candidate queue */
5798 * Check ranged rows for possible solutions, possibly detect infeasibility, fix variables due to having only one possible
5799 * solution, tighten bounds if having only two possible solutions or add constraints which propagate a subset of
5884 addartconss = conshdlrdata->rangedrowartcons && SCIPgetDepth(scip) < 1 && !SCIPinProbing(scip) && !SCIPinRepropagation(scip);
5889 /* we are not allowed to add artificial constraints during propagation; if nothing changed on this constraint since
5890 * the last rangedrowpropagation, we can stop; otherwise, we mark this constraint to be rangedrowpropagated without
5908 if( SCIPisEQ(scip, SCIPvarGetLbLocal(consdata->vars[v]), SCIPvarGetUbLocal(consdata->vars[v])) )
5937 * coefficient so that all variables in this group will have a gcd greater than 1, this group will be implicitly
5940 * the second group will contain all left unfixed variables and will be saved as infcheckvars with corresponding
5941 * coefficients as infcheckvals, the order of these variables should be the same as in the consdata object
5944 /* find first integral variables with integral coefficient greater than 1, thereby collecting all other unfixed