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*/
97 #define CONSHDLR_ENFOPRIORITY -1000000 /**< priority of the constraint handler for constraint enforcing */
98 #define CONSHDLR_CHECKPRIORITY -1000000 /**< priority of the constraint handler for checking feasibility */
99 #define CONSHDLR_SEPAFREQ 0 /**< frequency for separating cuts; zero means to separate only in the root node */
100 #define CONSHDLR_PROPFREQ 1 /**< frequency for propagating domains; zero means only preprocessing propagation */
101 #define CONSHDLR_EAGERFREQ 100 /**< frequency for using all instead of only the useful constraints in separation,
103 #define CONSHDLR_MAXPREROUNDS -1 /**< maximal number of presolving rounds the constraint handler participates in (-1: no limit) */
104 #define CONSHDLR_DELAYSEPA FALSE /**< should separation method be delayed, if other separators found cuts? */
105 #define CONSHDLR_DELAYPROP FALSE /**< should propagation method be delayed, if other propagators found reductions? */
106 #define CONSHDLR_NEEDSCONS TRUE /**< should the constraint handler be skipped, if no constraints are available? */
108 #define CONSHDLR_PRESOLTIMING (SCIP_PRESOLTIMING_FAST | SCIP_PRESOLTIMING_EXHAUSTIVE) /**< presolving timing of the constraint handler (fast, medium, or exhaustive) */
118 #define DEFAULT_TIGHTENBOUNDSFREQ 1 /**< multiplier on propagation frequency, how often the bounds are tightened */
119 #define DEFAULT_MAXROUNDS 5 /**< maximal number of separation rounds per node (-1: unlimited) */
120 #define DEFAULT_MAXROUNDSROOT -1 /**< maximal number of separation rounds in the root node (-1: unlimited) */
122 #define DEFAULT_MAXSEPACUTSROOT 200 /**< maximal number of cuts separated per separation round in root node */
123 #define DEFAULT_PRESOLPAIRWISE TRUE /**< should pairwise constraint comparison be performed in presolving? */
124 #define DEFAULT_PRESOLUSEHASHING TRUE /**< should hash table be used for detecting redundant constraints in advance */
125 #define DEFAULT_NMINCOMPARISONS 200000 /**< number for minimal pairwise presolving comparisons */
126 #define DEFAULT_MINGAINPERNMINCOMP 1e-06 /**< minimal gain per minimal pairwise presolving comparisons to repeat pairwise
128 #define DEFAULT_SORTVARS TRUE /**< should variables be sorted after presolve w.r.t their coefficient absolute for faster
130 #define DEFAULT_CHECKRELMAXABS FALSE /**< should the violation for a constraint with side 0.0 be checked relative
132 #define DEFAULT_MAXAGGRNORMSCALE 0.0 /**< maximal allowed relative gain in maximum norm for constraint aggregation
134 #define DEFAULT_MAXEASYACTIVITYDELTA 1e6 /**< maximum activity delta to run easy propagation on linear constraint
136 #define DEFAULT_MAXCARDBOUNDDIST 0.0 /**< maximal relative distance from current node's dual bound to primal bound compared
138 #define DEFAULT_SEPARATEALL FALSE /**< should all constraints be subject to cardinality cut generation instead of only
140 #define DEFAULT_AGGREGATEVARIABLES TRUE /**< should presolving search for redundant variables in equations */
141 #define DEFAULT_SIMPLIFYINEQUALITIES TRUE /**< should presolving try to simplify inequalities */
143 #define DEFAULT_SINGLETONSTUFFING TRUE /**< should stuffing of singleton continuous variables be performed? */
144 #define DEFAULT_SINGLEVARSTUFFING FALSE /**< should single variable stuffing be performed, which tries to fulfill
146 #define DEFAULT_DETECTCUTOFFBOUND TRUE /**< should presolving try to detect constraints parallel to the objective
149 #define DEFAULT_DETECTLOWERBOUND TRUE /**< should presolving try to detect constraints parallel to the objective
152 #define DEFAULT_DETECTPARTIALOBJECTIVE TRUE/**< should presolving try to detect subsets of constraints parallel to the
155 #define DEFAULT_RANGEDROWARTCONS TRUE /**< should presolving and propagation extract sub-constraints from ranged rows and equations? */
159 #define DEFAULT_MULTAGGRREMOVE FALSE /**< should multi-aggregations only be performed if the constraint can be
161 #define DEFAULT_MAXMULTAGGRQUOT 1e+03 /**< maximum coefficient dynamism (ie. maxabsval / minabsval) for multiaggregation */
162 #define DEFAULT_MAXDUALMULTAGGRQUOT 1e+20 /**< maximum coefficient dynamism (ie. maxabsval / minabsval) for multiaggregation */
167 #define MAXSCALEDCOEFINTEGER 0 /**< maximal coefficient value after scaling if all variables are of integral
174 #define MAXVALRECOMP 1e+06 /**< maximal abolsute value we trust without recomputing the activity */
175 #define MINVALRECOMP 1e-05 /**< minimal abolsute value we trust without recomputing the activity */
178 #define NONLINCONSUPGD_PRIORITY 1000000 /**< priority of the constraint handler for upgrading of expressions constraints */
180 /* @todo add multi-aggregation of variables that are in exactly two equations (, if not numerically an issue),
187 {
192 QUAD_MEMBER(SCIP_Real minactivity); /**< minimal value w.r.t. the variable's local bounds for the constraint's
194 QUAD_MEMBER(SCIP_Real maxactivity); /**< maximal value w.r.t. the variable's local bounds for the constraint's
200 QUAD_MEMBER(SCIP_Real glbminactivity); /**< minimal value w.r.t. the variable's global bounds for the constraint's
202 QUAD_MEMBER(SCIP_Real glbmaxactivity); /**< maximal value w.r.t. the variable's global bounds for the constraint's
204 SCIP_Real lastglbminactivity; /**< last global minimal activity which was computed by complete summation
206 SCIP_Real lastglbmaxactivity; /**< last global maximal activity which was computed by complete summation
208 SCIP_Real maxactdelta; /**< maximal activity contribution of a single variable, or SCIP_INVALID if invalid */
209 SCIP_VAR* maxactdeltavar; /**< variable with maximal activity contribution, or NULL if invalid */
217 int minactivityneginf; /**< number of coefficients contributing with neg. infinite value to minactivity */
218 int minactivityposinf; /**< number of coefficients contributing with pos. infinite value to minactivity */
219 int maxactivityneginf; /**< number of coefficients contributing with neg. infinite value to maxactivity */
220 int maxactivityposinf; /**< number of coefficients contributing with pos. infinite value to maxactivity */
221 int minactivityneghuge; /**< number of coefficients contributing with huge neg. value to minactivity */
222 int minactivityposhuge; /**< number of coefficients contributing with huge pos. value to minactivity */
223 int maxactivityneghuge; /**< number of coefficients contributing with huge neg. value to maxactivity */
224 int maxactivityposhuge; /**< number of coefficients contributing with huge pos. value to maxactivity */
225 int glbminactivityneginf;/**< number of coefficients contrib. with neg. infinite value to glbminactivity */
226 int glbminactivityposinf;/**< number of coefficients contrib. with pos. infinite value to glbminactivity */
227 int glbmaxactivityneginf;/**< number of coefficients contrib. with neg. infinite value to glbmaxactivity */
228 int glbmaxactivityposinf;/**< number of coefficients contrib. with pos. infinite value to glbmaxactivity */
229 int glbminactivityneghuge;/**< number of coefficients contrib. with huge neg. value to glbminactivity */
230 int glbminactivityposhuge;/**< number of coefficients contrib. with huge pos. value to glbminactivity */
231 int glbmaxactivityneghuge;/**< number of coefficients contrib. with huge neg. value to glbmaxactivity */
232 int glbmaxactivityposhuge;/**< number of coefficients contrib. with huge pos. value to glbmaxactivity */
239 unsigned int rangedrowpropagated:2; /**< did we perform ranged row propagation on this constraint?
251 unsigned int changed:1; /**< was constraint changed since last aggregation round in preprocessing? */
254 unsigned int upgraded:1; /**< is the constraint upgraded and will it be removed after preprocessing? */
259 unsigned int coefsorted:1; /**< are variables sorted by type and their absolute activity delta? */
261 unsigned int hascontvar:1; /**< does the constraint contain at least one continuous variable? */
262 unsigned int hasnonbinvar:1; /**< does the constraint contain at least one non-binary variable? */
263 unsigned int hasnonbinvalid:1; /**< is the information stored in hasnonbinvar and hascontvar valid? */
264 unsigned int checkabsolute:1; /**< should the constraint be checked w.r.t. an absolute feasibilty tolerance? */
279 SCIP_LINCONSUPGRADE** linconsupgrades; /**< linear constraint upgrade methods for specializing linear constraints */
280 SCIP_Real maxaggrnormscale; /**< maximal allowed relative gain in maximum norm for constraint aggregation
282 SCIP_Real maxcardbounddist; /**< maximal relative distance from current node's dual bound to primal bound compared
284 SCIP_Real mingainpernmincomp; /**< minimal gain per minimal pairwise presolving comparisons to repeat pairwise comparison round */
285 SCIP_Real maxeasyactivitydelta;/**< maximum activity delta to run easy propagation on linear constraint
289 int tightenboundsfreq; /**< multiplier on propagation frequency, how often the bounds are tightened */
296 SCIP_Bool presolpairwise; /**< should pairwise constraint comparison be performed in presolving? */
297 SCIP_Bool presolusehashing; /**< should hash table be used for detecting redundant constraints in advance */
298 SCIP_Bool separateall; /**< should all constraints be subject to cardinality cut generation instead of only
300 SCIP_Bool aggregatevariables; /**< should presolving search for redundant variables in equations */
301 SCIP_Bool simplifyinequalities;/**< should presolving try to cancel down or delete coefficients in inequalities */
303 SCIP_Bool singletonstuffing; /**< should stuffing of singleton continuous variables be performed? */
304 SCIP_Bool singlevarstuffing; /**< should single variable stuffing be performed, which tries to fulfill
307 SCIP_Bool checkrelmaxabs; /**< should the violation for a constraint with side 0.0 be checked relative
309 SCIP_Bool detectcutoffbound; /**< should presolving try to detect constraints parallel to the objective
312 SCIP_Bool detectlowerbound; /**< should presolving try to detect constraints parallel to the objective
315 SCIP_Bool detectpartialobjective;/**< should presolving try to detect subsets of constraints parallel to
317 SCIP_Bool rangedrowpropagation;/**< should presolving and propagation try to improve bounds, detect
320 SCIP_Bool rangedrowartcons; /**< should presolving and propagation extract sub-constraints from ranged rows and equations?*/
323 SCIP_Bool multaggrremove; /**< should multi-aggregations only be performed if the constraint can be
325 SCIP_Real maxmultaggrquot; /**< maximum coefficient dynamism (ie. maxabsval / minabsval) for primal multiaggregation */
326 SCIP_Real maxdualmultaggrquot;/**< maximum coefficient dynamism (ie. maxabsval / minabsval) for dual multiaggregation */
349 PROPRULE_1_RANGEDROW = 3, /**< fixed variables and gcd of all left variables tighten bounds of a
364 } asbits;
366 } val;
387 )
429 /** constructs an inference information out of a propagation rule and a position number, returns info as int */
450 )
461 SCIP_CALL( SCIPreallocBlockMemoryArray(scip, &conshdlrdata->linconsupgrades, conshdlrdata->linconsupgradessize, newsize) );
490 SCIP_CALL( SCIPreallocBlockMemoryArray(scip, &consdata->eventdata, consdata->varssize, newsize) );
546 {
580 SCIPfreeBlockMemoryArrayNull(scip, &(*conshdlrdata)->linconsupgrades, (*conshdlrdata)->linconsupgradessize);
606 SCIPwarningMessage(scip, "Try to add already known upgrade message for constraint handler %s.\n", conshdlrname);
629 SCIP_CALL( conshdlrdataEnsureLinconsupgradesSize(scip, conshdlrdata, conshdlrdata->nlinconsupgrades+1) );
636 assert(0 <= i && i <= conshdlrdata->nlinconsupgrades);
647 /** installs rounding locks for the given variable associated to the given coefficient in the linear constraint */
680 /** removes rounding locks for the given variable associated to the given coefficient in the linear constraint */
774 assert(consdata->eventdata[pos]->cons == cons);
922 if( SCIPisConsCompressionEnabled(scip) && SCIPisEQ(scip, SCIPvarGetLbGlobal(var), SCIPvarGetUbGlobal(var)) )
964 /* due to compressed copying, we may have fixed variables contributing to the left and right hand side */
1036 SCIP_CALL( SCIPgetTransformedVars(scip, (*consdata)->nvars, (*consdata)->vars, (*consdata)->vars) );
1120 {
1122 SCIP_CALL( SCIPwriteVarsLinearsum(scip, file, consdata->vars, consdata->vals, consdata->nvars, TRUE) );
1155 SCIPmessageFPrintInfo(SCIPgetMessagehdlr(scip), file, " [%s] <%s>: ", SCIPconshdlrGetName(SCIPconsGetHdlr(cons)), SCIPconsGetName(cons));
1277 bound = (SCIPvarGetBestBoundType(consdata->vars[i]) == SCIP_BOUNDTYPE_LOWER) ? SCIPvarGetLbLocal(consdata->vars[i]) : SCIPvarGetUbLocal(consdata->vars[i]);
1323 bound = (consdata->vals[i] > 0.0 ) ? SCIPvarGetLbLocal(consdata->vars[i]) : SCIPvarGetUbLocal(consdata->vars[i]);
1325 && !SCIPisHugeValue(scip, consdata->vals[i] * bound) && !SCIPisHugeValue(scip, -consdata->vals[i] * bound) )
1350 bound = (consdata->vals[i] > 0.0 ) ? SCIPvarGetUbLocal(consdata->vars[i]) : SCIPvarGetLbLocal(consdata->vars[i]);
1352 && !SCIPisHugeValue(scip, consdata->vals[i] * bound) && !SCIPisHugeValue(scip, -consdata->vals[i] * bound) )
1377 bound = (consdata->vals[i] > 0.0 ) ? SCIPvarGetLbGlobal(consdata->vars[i]) : SCIPvarGetUbGlobal(consdata->vars[i]);
1379 && !SCIPisHugeValue(scip, consdata->vals[i] * bound) && !SCIPisHugeValue(scip, -consdata->vals[i] * bound) )
1380 SCIPquadprecSumQD(consdata->glbminactivity, consdata->glbminactivity, consdata->vals[i] * bound);
1404 bound = (consdata->vals[i] > 0.0 ) ? SCIPvarGetUbGlobal(consdata->vars[i]) : SCIPvarGetLbGlobal(consdata->vars[i]);
1406 && !SCIPisHugeValue(scip, consdata->vals[i] * bound) && !SCIPisHugeValue(scip, -consdata->vals[i] * bound) )
1407 SCIPquadprecSumQD(consdata->glbmaxactivity, consdata->glbmaxactivity, consdata->vals[i] * bound);
1438 }
1462 {
1470 /** checks the type of all variables of the constraint and sets hasnonbinvar and hascontvar flags accordingly */
1491 {
1567 {
1619 SCIP_Bool checkreliability /**< should the reliability of the recalculated activity be checked? */
1671 * lower bound + neg. coef: update maxactivity, positive and negative infinity counters have to be switched
1673 * upper bound + neg. coef: update minactivity, positive and negative infinity counters have to be switched
1727 * lower bound + neg. coef: update maxactivity, positive and negative infinity counters have to be switched
1729 * upper bound + neg. coef: update minactivity, positive and negative infinity counters have to be switched
1797 /* if the bound changed to -infinity, increase the counter for negative infinite contributions */
1825 /* if the bound changed to +infinity, increase the counter for positive infinite contributions */
1850 * but checking here that the bound is not huge again would not handle a change from a huge to an infinite bound
1856 /* if the bound changed to +infinity, increase the counter for positive infinite contributions */
1859 /* if the bound changed to -infinity, increase the counter for negative infinite contributions */
1865 /* if the contribution of this variable is too large and positive, increase the corresponding counter */
1868 /* if the contribution of this variable is too large and negative, increase the corresponding counter */
1883 * but checking here that the bound is not huge again would not handle a change from a huge to an infinite bound
1889 /* if the bound changed to +infinity, increase the counter for positive infinite contributions */
1892 /* if the bound changed to -infinity, increase the counter for negative infinite contributions */
1898 /* if the contribution of this variable is too large and positive, increase the corresponding counter */
1901 /* if the contribution of this variable is too large and negative, increase the corresponding counter */
1953 /* update the activity, if the current value is valid and there was a change in the finite part */
2006 SCIP_Bool checkreliability /**< should the reliability of the recalculated activity be checked? */
2015 consdataUpdateActivities(scip, consdata, var, oldlb, newlb, val, SCIP_BOUNDTYPE_LOWER, FALSE, checkreliability);
2017 assert(!SCIPisInfinity(scip, -QUAD_TO_DBL(consdata->minactivity)) && !SCIPisInfinity(scip, QUAD_TO_DBL(consdata->minactivity)));
2018 assert(!SCIPisInfinity(scip, -QUAD_TO_DBL(consdata->maxactivity)) && !SCIPisInfinity(scip, QUAD_TO_DBL(consdata->maxactivity)));
2031 SCIP_Bool checkreliability /**< should the reliability of the recalculated activity be checked? */
2040 consdataUpdateActivities(scip, consdata, var, oldub, newub, val, SCIP_BOUNDTYPE_UPPER, FALSE, checkreliability);
2042 assert(!SCIPisInfinity(scip, -QUAD_TO_DBL(consdata->minactivity)) && !SCIPisInfinity(scip, QUAD_TO_DBL(consdata->minactivity)));
2043 assert(!SCIPisInfinity(scip, -QUAD_TO_DBL(consdata->maxactivity)) && !SCIPisInfinity(scip, QUAD_TO_DBL(consdata->maxactivity)));
2055 SCIP_Bool checkreliability /**< should the reliability of the recalculated activity be checked? */
2063 consdataUpdateActivities(scip, consdata, NULL, oldlb, newlb, val, SCIP_BOUNDTYPE_LOWER, TRUE, checkreliability);
2065 assert(!SCIPisInfinity(scip, -QUAD_TO_DBL(consdata->glbminactivity)) && !SCIPisInfinity(scip, QUAD_TO_DBL(consdata->glbminactivity)));
2066 assert(!SCIPisInfinity(scip, -QUAD_TO_DBL(consdata->glbmaxactivity)) && !SCIPisInfinity(scip, QUAD_TO_DBL(consdata->glbmaxactivity)));
2068 }
2078 SCIP_Bool checkreliability /**< should the reliability of the recalculated activity be checked? */
2086 consdataUpdateActivities(scip, consdata, NULL, oldub, newub, val, SCIP_BOUNDTYPE_UPPER, TRUE, checkreliability);
2088 assert(!SCIPisInfinity(scip, -QUAD_TO_DBL(consdata->glbminactivity)) && !SCIPisInfinity(scip, QUAD_TO_DBL(consdata->glbminactivity)));
2089 assert(!SCIPisInfinity(scip, -QUAD_TO_DBL(consdata->glbmaxactivity)) && !SCIPisInfinity(scip, QUAD_TO_DBL(consdata->glbmaxactivity)));
2091 }
2093 /** updates minimum and maximum activity and maximum absolute value for coefficient addition */
2100 SCIP_Bool checkreliability /**< should the reliability of the recalculated activity be checked? */
2136 consdataUpdateActivitiesLb(scip, consdata, var, 0.0, SCIPvarGetLbLocal(var), val, checkreliability);
2137 consdataUpdateActivitiesUb(scip, consdata, var, 0.0, SCIPvarGetUbLocal(var), val, checkreliability);
2138 consdataUpdateActivitiesGlbLb(scip, consdata, 0.0, SCIPvarGetLbGlobal(var), val, checkreliability);
2139 consdataUpdateActivitiesGlbUb(scip, consdata, 0.0, SCIPvarGetUbGlobal(var), val, checkreliability);
2143 /** updates minimum and maximum activity for coefficient deletion, invalidates maximum absolute value if necessary */
2150 SCIP_Bool checkreliability /**< should the reliability of the recalculated activity be checked? */
2193 consdataUpdateActivitiesLb(scip, consdata, var, SCIPvarGetLbLocal(var), 0.0, val, checkreliability);
2194 consdataUpdateActivitiesUb(scip, consdata, var, SCIPvarGetUbLocal(var), 0.0, val, checkreliability);
2195 consdataUpdateActivitiesGlbLb(scip, consdata, SCIPvarGetLbGlobal(var), 0.0, val, checkreliability);
2196 consdataUpdateActivitiesGlbUb(scip, consdata, SCIPvarGetUbGlobal(var), 0.0, val, checkreliability);
2200 /** updates minimum and maximum activity for coefficient change, invalidates maximum absolute value if necessary */
2208 SCIP_Bool checkreliability /**< should the reliability of the recalculated activity be checked? */
2288 /* reset maximal activity delta, so that it will be recalculated on the next real propagation */
2294 /* @todo do something more clever here, e.g. if oldval * newval >= 0, do the update directly */
2320 {
2393 /** gets minimal activity for constraint and given values of counters for infinite and huge contributions
2394 * and (if needed) delta to subtract from stored finite part of activity in case of a residual activity
2407 SCIP_Bool goodrelax, /**< should a good relaxation be computed or are relaxed acticities ignored, anyway? */
2411 SCIP_Bool* issettoinfinity /**< pointer to store whether minactivity was set to infinity or calculated */
2416 assert(posinf >= 0);
2438 /* if we have neg. huge contributions, we only know that -infty is a relaxation of the minactivity */
2445 /* we do not need a good relaxation and we have positive huge contributions, so we just return -infty as activity */
2476 * times the minimum value counting as "huge" plus finite (and non-huge) part of minactivity - delta
2494 /** gets maximal activity for constraint and given values of counters for infinite and huge contributions
2495 * and (if needed) delta to subtract from stored finite part of activity in case of a residual activity
2508 SCIP_Bool goodrelax, /**< should a good relaxation be computed or are relaxed acticities ignored, anyway? */
2512 SCIP_Bool* issettoinfinity /**< pointer to store whether maxactivity was set to infinity or calculated */
2517 assert(posinf >= 0);
2539 /* if we have pos. huge contributions, we only know that +infty is a relaxation of the maxactivity */
2546 /* we do not need a good relaxation and we have positve huge contributions, so we just return +infty as activity */
2577 * times the minimum value counting as "huge" plus the finite (and non-huge) part of maxactivity minus delta
2604 SCIP_Bool* minisrelax, /**< pointer to store whether the returned minactivity is just a relaxation,
2607 SCIP_Bool* maxisrelax, /**< pointer to store whether the returned maxactivity is just a relaxation,
2610 SCIP_Bool* isminsettoinfinity, /**< pointer to store whether minactivity was set to infinity or calculated */
2611 SCIP_Bool* ismaxsettoinfinity /**< pointer to store whether maxactivity was set to infinity or calculated */
2736 SCIP_Bool* minisrelax, /**< pointer to store whether the returned residual minactivity is just a
2739 SCIP_Bool* maxisrelax, /**< pointer to store whether the returned residual maxactivity is just a
2742 SCIP_Bool* isminsettoinfinity, /**< pointer to store whether minresactivity was set to infinity or calculated */
2743 SCIP_Bool* ismaxsettoinfinity /**< pointer to store whether maxresactivity was set to infinity or calculated */
2791 /* get/compute minactivity by calling getMinActivity() with updated counters for infinite and huge values
2792 * and contribution of variable set to zero that has to be subtracted from finite part of activity
2829 consdata->minactivityposhuge, consdata->minactivityneghuge, absval * minactbound, FALSE, goodrelax,
2833 /* get/compute maxactivity by calling getMaxActivity() with updated counters for infinite and huge values
2834 * and contribution of variable set to zero that has to be subtracted from finite part of activity
2871 consdata->maxactivityposhuge, consdata->maxactivityneghuge, absval * maxactbound, FALSE, goodrelax,
2883 SCIP_Real* glbminactivity, /**< pointer to store the minimal activity, or NULL, if not needed */
2884 SCIP_Real* glbmaxactivity, /**< pointer to store the maximal activity, or NULL, if not needed */
2885 SCIP_Bool* minisrelax, /**< pointer to store whether the returned minactivity is just a relaxation,
2888 SCIP_Bool* maxisrelax, /**< pointer to store whether the returned maxactivity is just a relaxation,
2891 SCIP_Bool* isminsettoinfinity, /**< pointer to store whether minresactivity was set to infinity or calculated */
2892 SCIP_Bool* ismaxsettoinfinity /**< pointer to store whether maxresactivity was set to infinity or calculated */
2947 SCIP_Real* minresactivity, /**< pointer to store the minimal residual activity, or NULL, if not needed */
2948 SCIP_Real* maxresactivity, /**< pointer to store the maximal residual activity, or NULL, if not needed */
2949 SCIP_Bool* minisrelax, /**< pointer to store whether the returned residual minactivity is just a
2952 SCIP_Bool* maxisrelax, /**< pointer to store whether the returned residual maxactivity is just a
2955 SCIP_Bool* isminsettoinfinity, /**< pointer to store whether minresactivity was set to infinity or calculated */
2956 SCIP_Bool* ismaxsettoinfinity /**< pointer to store whether maxresactivity was set to infinity or calculated */
2998 /* get/compute minactivity by calling getMinActivity() with updated counters for infinite and huge values
2999 * and contribution of variable set to zero that has to be subtracted from finite part of activity
3005 getMinActivity(scip, consdata, consdata->glbminactivityposinf - 1, consdata->glbminactivityneginf,
3013 getMinActivity(scip, consdata, consdata->glbminactivityposinf, consdata->glbminactivityneginf - 1,
3046 /* get/compute maxactivity by calling getMaxActivity() with updated counters for infinite and huge values
3047 * and contribution of variable set to zero that has to be subtracted from finite part of activity
3053 getMaxActivity(scip, consdata, consdata->glbmaxactivityposinf, consdata->glbmaxactivityneginf - 1,
3061 getMaxActivity(scip, consdata, consdata->glbmaxactivityposinf - 1, consdata->glbmaxactivityneginf,
3128 else if( (SCIPisInfinity(scip, solval) && negsign) || (SCIPisInfinity(scip, -solval) && !negsign) )
3135 SCIPdebugMsg(scip, "activity of linear constraint: %.15g, %d positive infinity values, %d negative infinity values \n", activity, nposinf, nneginf);
3224 /** index comparison method of linear constraints: compares two indices of the variable set in the linear constraint */
3263 /** index comparison method of linear constraints: compares two indices of the variable set in the linear constraint */
3319 SCIP_Real abscont1 = REALABS(consdata->vals[ind1] * (SCIPvarGetUbGlobal(var1) - SCIPvarGetLbGlobal(var1)));
3320 SCIP_Real abscont2 = REALABS(consdata->vals[ind2] * (SCIPvarGetUbGlobal(var2) - SCIPvarGetLbGlobal(var2)));
3354 {
3404 * sorts variables of the remaining problem by binaries, integers, implicit integers, and continuous variables,
3525 /* the left hand side switched from -infinity to a non-infinite value -> install rounding locks */
3550 /* the left hand side switched from a non-infinite value to -infinity -> remove rounding locks */
3571 /* 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 */
3653 /* the right hand side switched from infinity to a non-infinite value -> install rounding locks */
3678 /* the right hand side switched from a non-infinite value to infinity -> remove rounding locks */
3699 /* 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 */
3747 assert(!SCIPvarIsRelaxationOnly(var) || (!SCIPconsIsChecked(cons) && !SCIPconsIsEnforced(cons)));
3862 consdata->indexsorted = consdata->indexsorted && (consdataCompVar((void*)consdata, consdata->nvars-2, consdata->nvars-1) <= 0);
3868 consdata->coefsorted = consdata->coefsorted && (consdataCompVarProp((void*)consdata, consdata->nvars-2, consdata->nvars-1) <= 0);
3959 /* if at most one variable is left, the activities should be recalculated (to correspond exactly to the bounds
3971 /* if the variable defining the maximal activity delta was removed from the constraint, the maximal activity
4037 assert(0 <= pos && pos < consdata->nvars);
4119 SCIPwarningMessage(scip, "skipped scaling for linear constraint <%s> to avoid numerical troubles (scalar: %.15g)\n",
4130 /* because SCIPisScalingIntegral uses another integrality check as SCIPfeasFloor, we add an additional 0.5 before
4138 SCIPwarningMessage(scip, "coefficient %.15g of variable <%s> in linear constraint <%s> scaled to zero (scalar: %.15g)\n",
4160 /* because SCIPisScalingIntegral uses another integrality check as SCIPfeasFloor, we add an additional 0.5 before
4172 /* because SCIPisScalingIntegral uses another integrality check as SCIPfeasCeil, we subtract 0.5 before ceiling up
4209 {
4234 * Apply the following rules in the given order, until the sign of the factor is determined. Later rules only apply,
4239 * 4. the number of positive coefficients must not be smaller than the number of negative coefficients
4242 * Try to identify a rational representation of the fractional coefficients, and multiply all coefficients
4333 SCIPdebugMsg(scip, "divide linear constraint with %g, because all coefficients are in absolute value the same\n", maxabsval);
4375 epsilon = SCIPepsilon(scip) * 0.9; /* slightly decrease epsilon to be safe in rational conversion below */
4384 maxmult = MIN(maxmult, (SCIP_Longint) (MAXSCALEDCOEFINTEGER / MAX(maxabsval, 1.0))); /*lint !e835*/
4410 /* 3. the absolute value of the right hand side must be greater than that of the left hand side */
4419 /* 4. the number of positive coefficients must not be smaller than the number of negative coefficients */
4472 /* it might be that we have really big coefficients, but all are integral, in that case we want to divide them by
4492 SCIPdebugMsg(scip, "scale linear constraint with %" SCIP_LONGINT_FORMAT " to make coefficients integral\n", scm);
4541 /* since the lhs/rhs is not respected for gcd calculation it can happen that we detect infeasibility */
4544 if( SCIPisEQ(scip, consdata->lhs, consdata->rhs) && !SCIPisFeasIntegral(scip, consdata->rhs / gcd) )
4548 SCIPdebugMsg(scip, "detected infeasibility of constraint after scaling with gcd=%" SCIP_LONGINT_FORMAT ":\n", gcd);
4556 SCIPdebugMsg(scip, "divide linear constraint by greatest common divisor %" SCIP_LONGINT_FORMAT "\n", gcd);
4629 /* if the variable defining the maximal activity delta was removed from the constraint, the maximal activity
4702 /* if an unmodifiable row has been added to the LP, then we cannot apply fixing anymore (cannot change a row)
4703 * this should not happen, as applyFixings is called in addRelaxation() before creating and adding a row
4705 assert(consdata->row == NULL || !SCIProwIsInLP(consdata->row) || SCIProwIsModifiable(consdata->row));
4858 if( SCIPisEQ(scip, lhssubtrahend, consdata->lhs) && SCIPisFeasGE(scip, REALABS(lhssubtrahend), 1.0) )
4874 if( SCIPisEQ(scip, rhssubtrahend, consdata->rhs ) && SCIPisFeasGE(scip, REALABS(rhssubtrahend), 1.0) )
4888 /* if aggregated variables have been replaced, multiple entries of the same variable are possible and we have
4907 /** for each variable in the linear constraint, except the inferred variable, adds one bound to the conflict analysis'
4908 * candidate store (bound depends on sign of coefficient and whether the left or right hand side was the reason for the
4909 * inference variable's bound change); the conflict analysis can be initialized with the linear constraint being the
4917 SCIP_BDCHGIDX* bdchgidx, /**< bound change index (time stamp of bound change), or NULL for current time */
4946 /* for each variable, add the bound to the conflict queue, that is responsible for the minimal or maximal
4947 * residual value, depending on whether the left or right hand side is responsible for the bound change:
4952 /* if the variable is integral we only need to add reason bounds until the propagation could be applied */
4965 /* calculate the minimal and maximal global activity of all other variables involved in the constraint */
4970 consdataGetGlbActivityResiduals(scip, consdata, infervar, vals[inferpos], FALSE, &minresactivity, NULL,
4973 consdataGetGlbActivityResiduals(scip, consdata, infervar, vals[inferpos], FALSE, NULL, &maxresactivity,
4987 if( (reasonisrhs && !isminsettoinfinity && !minisrelax) || (!reasonisrhs && !ismaxsettoinfinity && !maxisrelax) ) /*lint !e644*/
4994 /* calculate the residual capacity that would be left, if the variable would be set to one more / one less
5049 /* rhs is reason and coeff is positive, or lhs is reason and coeff is negative -> lower bound */
5051 rescap -= vals[i] * (SCIPgetVarLbAtIndex(scip, vars[i], bdchgidx, FALSE) - SCIPvarGetLbGlobal(vars[i]));
5055 /* lhs is reason and coeff is positive, or rhs is reason and coeff is negative -> upper bound */
5057 rescap -= vals[i] * (SCIPgetVarUbAtIndex(scip, vars[i], bdchgidx, FALSE) - SCIPvarGetUbGlobal(vars[i]));
5077 /* rhs is reason and coeff is positive, or lhs is reason and coeff is negative -> lower bound is responsible */
5082 /* lhs is reason and coeff is positive, or rhs is reason and coeff is negative -> upper bound is responsible */
5090 /** for each variable in the linear ranged row constraint, except the inferred variable, adds the bounds of all fixed
5091 * variables to the conflict analysis' candidate store; the conflict analysis can be initialized
5092 * with the linear constraint being the conflict detecting constraint by using NULL as inferred variable
5099 SCIP_BDCHGIDX* bdchgidx, /**< bound change index (time stamp of bound change), or NULL for current time */
5114 nvars = consdata->nvars;
5131 if( !SCIPisEQ(scip, SCIPgetVarLbAtIndex(scip, vars[v], bdchgidx, FALSE), SCIPvarGetLbGlobal(vars[v])) )
5137 if( !SCIPisEQ(scip, SCIPgetVarUbAtIndex(scip, vars[v], bdchgidx, FALSE), SCIPvarGetUbGlobal(vars[v])) )
5147 if( SCIPisEQ(scip, SCIPgetVarLbAtIndex(scip, vars[v], bdchgidx, FALSE), SCIPgetVarUbAtIndex(scip, vars[v], bdchgidx, FALSE)) )
5149 /* add all bounds of fixed variables which lead to the boundchange of the given inference variable */
5179 {
5206 /** resolves a propagation on the given variable by supplying the variables needed for applying the corresponding
5217 SCIP_BDCHGIDX* bdchgidx, /**< bound change index (time stamp of bound change), or NULL for current time */
5218 SCIP_RESULT* result /**< pointer to store the result of the propagation conflict resolving call */
5259 /* the bound of the variable was tightened, because the minimal or maximal residual activity of the linear
5260 * constraint (only taking the other variables into account) didn't leave enough space for a larger
5269 /* the bound of the variable was tightened, because the minimal or maximal residual activity of the linear
5270 * constraint (only taking the other variables into account) didn't leave enough space for a larger
5279 /* the bound of the variable was tightened, because some variables were already fixed and the leftover only allow
5291 SCIPerrorMessage("invalid inference information %d in linear constraint <%s> at position %d for %s bound of variable <%s>\n",
5302 /** analyzes conflicting bounds on given constraint, and adds conflict constraint to problem */
5311 if( (SCIPgetStage(scip) != SCIP_STAGE_SOLVING && !SCIPinProbing(scip)) || !SCIPisConflictAnalysisApplicable(scip) )
5317 /* add the conflicting bound for each variable of infeasible constraint to conflict candidate queue */
5365 SCIP_Bool force /**< should a possible bound change be forced even if below bound strengthening tolerance */
5389 SCIPdebugMsg(scip, "linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, activity=[%.15g,%.15g], sides=[%.15g,%.15g] -> newub=%.15g\n",
5391 QUAD_TO_DBL(consdata->minactivity), QUAD_TO_DBL(consdata->maxactivity), consdata->lhs, consdata->rhs, newub);
5396 SCIP_CALL( SCIPinferVarUbCons(scip, var, newub, cons, getInferInt(proprule, pos), force, &infeasible, &tightened) );
5435 SCIP_Bool force /**< should a possible bound change be forced even if below bound strengthening tolerance */
5459 SCIPdebugMsg(scip, "linear constraint <%s>: tighten <%s>, old bds=[%.15g,%.15g], val=%.15g, activity=[%.15g,%.15g], sides=[%.15g,%.15g] -> newlb=%.15g\n",
5461 QUAD_TO_DBL(consdata->minactivity), QUAD_TO_DBL(consdata->maxactivity), consdata->lhs, consdata->rhs, newlb);
5466 SCIP_CALL( SCIPinferVarLbCons(scip, var, newlb, cons, getInferInt(proprule, pos), force, &infeasible, &tightened) );
5502 SCIP_Bool force /**< should a possible bound change be forced even if below bound strengthening tolerance */
5562 /* min activity should be valid at this point (if this is not true, then some decisions might be wrong!) */
5565 /* if the minactivity is larger than the right hand side by feasibility epsilon, the constraint is infeasible */
5577 /* if the slack is zero in tolerances (or negative, but not enough to make the constraint infeasible), we set
5621 /* if the maxactivity is smaller than the left hand side by feasibility epsilon, the constraint is infeasible */
5633 /* if the slack is zero in tolerances (or negative, but not enough to make the constraint infeasible), we set
5669 /* min activity should be valid at this point (if this is not true, then some decisions might be wrong!) */
5672 /* if the minactivity is larger than the right hand side by feasibility epsilon, the constraint is infeasible */
5684 /* if the slack is zero in tolerances (or negative, but not enough to make the constraint infeasible), we set
5727 /* if the maxactivity is smaller than the left hand side by feasibility epsilon, the constraint is infeasible */
5739 /* if the slack is zero in tolerances (or negative, but not enough to make the constraint infeasible), we set
5771 /** analyzes conflicting bounds on given ranged row constraint, and adds conflict constraint to problem */
5794 if( (SCIPgetStage(scip) != SCIP_STAGE_SOLVING && !SCIPinProbing(scip)) || !SCIPisConflictAnalysisApplicable(scip) )
5800 /* add the conflicting fixed variables of this ranged row constraint to conflict candidate queue */
5814 * Check ranged rows for possible solutions, possibly detect infeasibility, fix variables due to having only one possible
5815 * solution, tighten bounds if having only two possible solutions or add constraints which propagate a subset of
5900 addartconss = conshdlrdata->rangedrowartcons && SCIPgetDepth(scip) < 1 && !SCIPinProbing(scip) && !SCIPinRepropagation(scip);
5905 /* we are not allowed to add artificial constraints during propagation; if nothing changed on this constraint since
5906 * the last rangedrowpropagation, we can stop; otherwise, we mark this constraint to be rangedrowpropagated without
5924 if( SCIPisEQ(scip, SCIPvarGetLbLocal(consdata->vars[v]), SCIPvarGetUbLocal(consdata->vars[v])) )