cons_linear.c File Reference

Detailed Description

Constraint handler for linear constraints in their most general form, \(lhs <= a^T x <= rhs\).

Author

Tobias Achterberg

Timo Berthold

Marc Pfetsch

Kati Wolter

Michael Winkler

Gerald Gamrath

Domenico Salvagnin

Linear constraints are separated with a high priority, because they are easy to separate. Instead of using the global cut pool, the same effect can be implemented by adding linear constraints to the root node, such that they are separated each time, the linear constraints are separated. A constraint handler, which generates linear constraints in this way should have a lower separation priority than the linear constraint handler, and it should have a separation frequency that is a multiple of the frequency of the linear constraint handler. In this way, it can be avoided to separate the same cut twice, because if a separation run of the handler is always preceded by a separation of the linear constraints, the priorily added constraints are always satisfied.

Linear constraints are enforced and checked with a very low priority. Checking of (many) linear constraints is much more involved than checking the solution values for integrality. Because we are separating the linear constraints quite often, it is only necessary to enforce them for integral solutions. A constraint handler which generates pool cuts in its enforcing method should have an enforcing priority smaller than that of the linear constraint handler to avoid regenerating constraints which already exist.

Definition in file cons_linear.c.

#include "blockmemshell/memory.h"
#include "scip/cons_nonlinear.h"
#include "scip/cons_knapsack.h"
#include "scip/cons_linear.h"
#include "scip/debug.h"
#include "scip/pub_conflict.h"
#include "scip/pub_cons.h"
#include "scip/pub_event.h"
#include "scip/pub_expr.h"
#include "scip/pub_lp.h"
#include "scip/pub_message.h"
#include "scip/pub_misc.h"
#include "scip/pub_misc_sort.h"
#include "scip/pub_var.h"
#include "scip/scip_branch.h"
#include "scip/scip_conflict.h"
#include "scip/scip_cons.h"
#include "scip/scip_copy.h"
#include "scip/scip_cut.h"
#include "scip/scip_event.h"
#include "scip/scip_general.h"
#include "scip/scip_lp.h"
#include "scip/scip_mem.h"
#include "scip/scip_message.h"
#include "scip/scip_numerics.h"
#include "scip/scip_param.h"
#include "scip/scip_prob.h"
#include "scip/scip_probing.h"
#include "scip/scip_sol.h"
#include "scip/scip_solvingstats.h"
#include "scip/scip_tree.h"
#include "scip/scip_var.h"
#include "scip/symmetry_graph.h"
#include "symmetry/struct_symmetry.h"
#include "scip/dbldblarith.h"

Go to the source code of this file.

Data Structures
struct	SCIP_LinConsUpgrade

Macros
#define	CONSHDLR_NAME   "linear"
#define	CONSHDLR_DESC   "linear constraints of the form lhs <= a^T x <= rhs"
#define	CONSHDLR_SEPAPRIORITY   +100000
#define	CONSHDLR_ENFOPRIORITY   -1000000
#define	CONSHDLR_CHECKPRIORITY   -1000000
#define	CONSHDLR_SEPAFREQ   0
#define	CONSHDLR_PROPFREQ   1
#define	CONSHDLR_EAGERFREQ   100
#define	CONSHDLR_MAXPREROUNDS   -1
#define	CONSHDLR_DELAYSEPA   FALSE
#define	CONSHDLR_DELAYPROP   FALSE
#define	CONSHDLR_NEEDSCONS   TRUE
#define	CONSHDLR_PRESOLTIMING   (SCIP_PRESOLTIMING_FAST | SCIP_PRESOLTIMING_EXHAUSTIVE)
#define	CONSHDLR_PROP_TIMING   SCIP_PROPTIMING_BEFORELP
#define	EVENTHDLR_NAME   "linear"
#define	EVENTHDLR_DESC   "bound change event handler for linear constraints"
#define	CONFLICTHDLR_NAME   "linear"
#define	CONFLICTHDLR_DESC   "conflict handler creating linear constraints"
#define	CONFLICTHDLR_PRIORITY   -1000000
#define	DEFAULT_TIGHTENBOUNDSFREQ   1
#define	DEFAULT_MAXROUNDS   5
#define	DEFAULT_MAXROUNDSROOT   -1
#define	DEFAULT_MAXSEPACUTS   50
#define	DEFAULT_MAXSEPACUTSROOT   200
#define	DEFAULT_PRESOLPAIRWISE   TRUE
#define	DEFAULT_PRESOLUSEHASHING   TRUE
#define	DEFAULT_NMINCOMPARISONS   200000
#define	DEFAULT_MINGAINPERNMINCOMP   1e-06
#define	DEFAULT_SORTVARS   TRUE
#define	DEFAULT_CHECKRELMAXABS   FALSE
#define	DEFAULT_MAXAGGRNORMSCALE   0.0
#define	DEFAULT_MAXEASYACTIVITYDELTA   1e6
#define	DEFAULT_MAXCARDBOUNDDIST   0.0
#define	DEFAULT_SEPARATEALL   FALSE
#define	DEFAULT_AGGREGATEVARIABLES   TRUE
#define	DEFAULT_SIMPLIFYINEQUALITIES   TRUE
#define	DEFAULT_DUALPRESOLVING   TRUE
#define	DEFAULT_SINGLETONSTUFFING   TRUE
#define	DEFAULT_SINGLEVARSTUFFING   FALSE
#define	DEFAULT_DETECTCUTOFFBOUND   TRUE
#define	DEFAULT_DETECTLOWERBOUND   TRUE
#define	DEFAULT_DETECTPARTIALOBJECTIVE   TRUE
#define	DEFAULT_RANGEDROWPROPAGATION   TRUE
#define	DEFAULT_RANGEDROWARTCONS   TRUE
#define	DEFAULT_RANGEDROWMAXDEPTH   INT_MAX
#define	DEFAULT_RANGEDROWFREQ   1
#define	DEFAULT_MULTAGGRREMOVE   FALSE
#define	DEFAULT_MAXMULTAGGRQUOT   1e+03
#define	DEFAULT_MAXDUALMULTAGGRQUOT   1e+20
#define	DEFAULT_EXTRACTCLIQUES   TRUE
#define	MAXDNOM   10000LL
#define	MAXSCALEDCOEF   0
#define	MAXSCALEDCOEFINTEGER   0
#define	MAXACTVAL   1e+09
#define	MAXVALRECOMP   1e+06
#define	MINVALRECOMP   1e-05
#define	NONLINCONSUPGD_PRIORITY   1000000
#define	checkMaxActivityDelta(scip, consdata)
#define	MAXTIGHTENROUNDS   10
#define	MAX_CLIQUE_NONZEROS_PER_CONS   1000000
#define	BINWEIGHT   1
#define	INTWEIGHT   4
#define	CONTWEIGHT   8
#define	MAXCONSPRESOLROUNDS   10

Typedefs
typedef enum Proprule	PROPRULE
typedef struct InferInfo	INFERINFO

Enumerations
enum	Proprule {   PROPRULE_INVALID = 0 ,   PROPRULE_1 = 1 ,   PROPRULE_2 = 2 ,   PROPRULE_3 = 3 ,   PROPRULE_4 = 4 ,   PROPRULE_0_INVALID = 0 ,   PROPRULE_1_CORETIMES = 1 ,   PROPRULE_2_EDGEFINDING = 2 ,   PROPRULE_3_TTEF = 3 ,   PROPRULE_1_RHS = 1 ,   PROPRULE_1_LHS = 2 ,   PROPRULE_1_RANGEDROW = 3 ,   PROPRULE_INVALID = 0 ,   PROPRULE_1_RHS = 1 ,   PROPRULE_1_LHS = 2 ,   PROPRULE_1_RANGEDROW = 3 ,   PROPRULE_INVALID = 0 ,   PROPRULE_1 = 0 ,   PROPRULE_2 = 1 ,   PROPRULE_3 = 2 ,   PROPRULE_4 = 3 ,   PROPRULE_INVALID = 4 ,   PROPRULE_1 ,   PROPRULE_2 ,   PROPRULE_3 ,   PROPRULE_4 ,   PROPRULE_0 ,   PROPRULE_1 ,   PROPRULE_INTLB ,   PROPRULE_INTUB ,   PROPRULE_INVALID }

Functions
static INFERINFO	intToInferInfo (int i)
static int	inferInfoToInt (INFERINFO inferinfo)
static int	inferInfoGetProprule (INFERINFO inferinfo)
static int	inferInfoGetPos (INFERINFO inferinfo)
static INFERINFO	getInferInfo (PROPRULE proprule, int pos)
static int	getInferInt (PROPRULE proprule, int pos)
static SCIP_RETCODE	conshdlrdataEnsureLinconsupgradesSize (SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, int num)
static SCIP_RETCODE	consdataEnsureVarsSize (SCIP *scip, SCIP_CONSDATA *consdata, int num)
static SCIP_RETCODE	linconsupgradeCreate (SCIP *scip, SCIP_LINCONSUPGRADE **linconsupgrade, SCIP_DECL_LINCONSUPGD((*linconsupgd)), int priority)
static void	linconsupgradeFree (SCIP *scip, SCIP_LINCONSUPGRADE **linconsupgrade)
static SCIP_RETCODE	conshdlrdataCreate (SCIP *scip, SCIP_CONSHDLRDATA **conshdlrdata, SCIP_EVENTHDLR *eventhdlr)
static void	conshdlrdataFree (SCIP *scip, SCIP_CONSHDLRDATA **conshdlrdata)
static SCIP_Bool	conshdlrdataHasUpgrade (SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_DECL_LINCONSUPGD((*linconsupgd)), const char *conshdlrname)
static SCIP_RETCODE	conshdlrdataIncludeUpgrade (SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_LINCONSUPGRADE *linconsupgrade)
static SCIP_RETCODE	lockRounding (SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)
static SCIP_RETCODE	unlockRounding (SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)
static SCIP_RETCODE	consCatchEvent (SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, int pos)
static SCIP_RETCODE	consDropEvent (SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, int pos)
static SCIP_RETCODE	consCatchAllEvents (SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr)
static SCIP_RETCODE	consDropAllEvents (SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr)
static SCIP_RETCODE	consdataCreate (SCIP *scip, SCIP_CONSDATA **consdata, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs)
static SCIP_RETCODE	consdataFree (SCIP *scip, SCIP_CONSDATA **consdata)
static SCIP_RETCODE	consdataPrint (SCIP *scip, SCIP_CONSDATA *consdata, FILE *file)
static SCIP_RETCODE	consPrintConsSol (SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, FILE *file)
static void	consdataInvalidateActivities (SCIP_CONSDATA *consdata)
static SCIP_Real	consdataComputePseudoActivity (SCIP *scip, SCIP_CONSDATA *consdata)
static void	consdataRecomputeMinactivity (SCIP *scip, SCIP_CONSDATA *consdata)
static void	consdataRecomputeMaxactivity (SCIP *scip, SCIP_CONSDATA *consdata)
static void	consdataRecomputeGlbMinactivity (SCIP *scip, SCIP_CONSDATA *consdata)
static void	consdataRecomputeGlbMaxactivity (SCIP *scip, SCIP_CONSDATA *consdata)
static void	consdataCalcMaxAbsval (SCIP_CONSDATA *consdata)
static void	consdataCalcMinAbsval (SCIP_CONSDATA *consdata)
static void	consdataCheckNonbinvar (SCIP_CONSDATA *consdata)
static void	consdataRecomputeMaxActivityDelta (SCIP *scip, SCIP_CONSDATA *consdata)
static void	consdataUpdateActivities (SCIP *scip, SCIP_CONSDATA *consdata, SCIP_VAR *var, SCIP_Real oldbound, SCIP_Real newbound, SCIP_Real val, SCIP_BOUNDTYPE boundtype, SCIP_Bool global, SCIP_Bool checkreliability)
static void	consdataUpdateActivitiesLb (SCIP *scip, SCIP_CONSDATA *consdata, SCIP_VAR *var, SCIP_Real oldlb, SCIP_Real newlb, SCIP_Real val, SCIP_Bool checkreliability)
static void	consdataUpdateActivitiesUb (SCIP *scip, SCIP_CONSDATA *consdata, SCIP_VAR *var, SCIP_Real oldub, SCIP_Real newub, SCIP_Real val, SCIP_Bool checkreliability)
static void	consdataUpdateActivitiesGlbLb (SCIP *scip, SCIP_CONSDATA *consdata, SCIP_Real oldlb, SCIP_Real newlb, SCIP_Real val, SCIP_Bool checkreliability)
static void	consdataUpdateActivitiesGlbUb (SCIP *scip, SCIP_CONSDATA *consdata, SCIP_Real oldub, SCIP_Real newub, SCIP_Real val, SCIP_Bool checkreliability)
static void	consdataUpdateAddCoef (SCIP *scip, SCIP_CONSDATA *consdata, SCIP_VAR *var, SCIP_Real val, SCIP_Bool checkreliability)
static void	consdataUpdateDelCoef (SCIP *scip, SCIP_CONSDATA *consdata, SCIP_VAR *var, SCIP_Real val, SCIP_Bool checkreliability)
static void	consdataUpdateChgCoef (SCIP *scip, SCIP_CONSDATA *consdata, SCIP_VAR *var, SCIP_Real oldval, SCIP_Real newval, SCIP_Bool checkreliability)
static SCIP_Real	consdataGetMaxAbsval (SCIP_CONSDATA *consdata)
static SCIP_Real	consdataGetMinAbsval (SCIP_CONSDATA *consdata)
static void	consdataCalcActivities (SCIP *scip, SCIP_CONSDATA *consdata)
static void	getMinActivity (SCIP *scip, SCIP_CONSDATA *consdata, int posinf, int neginf, int poshuge, int neghuge, SCIP_Real delta, SCIP_Bool global, SCIP_Bool goodrelax, SCIP_Real *minactivity, SCIP_Bool *istight, SCIP_Bool *issettoinfinity)
static void	getMaxActivity (SCIP *scip, SCIP_CONSDATA *consdata, int posinf, int neginf, int poshuge, int neghuge, SCIP_Real delta, SCIP_Bool global, SCIP_Bool goodrelax, SCIP_Real *maxactivity, SCIP_Bool *istight, SCIP_Bool *issettoinfinity)
static void	consdataGetActivityBounds (SCIP *scip, SCIP_CONSDATA *consdata, SCIP_Bool goodrelax, SCIP_Real *minactivity, SCIP_Real *maxactivity, SCIP_Bool *ismintight, SCIP_Bool *ismaxtight, SCIP_Bool *isminsettoinfinity, SCIP_Bool *ismaxsettoinfinity)
static void	consdataGetReliableResidualActivity (SCIP *scip, SCIP_CONSDATA *consdata, SCIP_VAR *cancelvar, SCIP_Real *resactivity, SCIP_Bool isminresact, SCIP_Bool useglobalbounds)
static void	consdataGetActivityResiduals (SCIP *scip, SCIP_CONSDATA *consdata, SCIP_VAR *var, SCIP_Real val, SCIP_Bool goodrelax, SCIP_Real *minresactivity, SCIP_Real *maxresactivity, SCIP_Bool *ismintight, SCIP_Bool *ismaxtight, SCIP_Bool *isminsettoinfinity, SCIP_Bool *ismaxsettoinfinity)
static void	consdataGetGlbActivityBounds (SCIP *scip, SCIP_CONSDATA *consdata, SCIP_Bool goodrelax, SCIP_Real *glbminactivity, SCIP_Real *glbmaxactivity, SCIP_Bool *ismintight, SCIP_Bool *ismaxtight, SCIP_Bool *isminsettoinfinity, SCIP_Bool *ismaxsettoinfinity)
static void	consdataGetGlbActivityResiduals (SCIP *scip, SCIP_CONSDATA *consdata, SCIP_VAR *var, SCIP_Real val, SCIP_Bool goodrelax, SCIP_Real *minresactivity, SCIP_Real *maxresactivity, SCIP_Bool *ismintight, SCIP_Bool *ismaxtight, SCIP_Bool *isminsettoinfinity, SCIP_Bool *ismaxsettoinfinity)
static SCIP_Real	consdataGetActivity (SCIP *scip, SCIP_CONSDATA *consdata, SCIP_SOL *sol)
static SCIP_Real	consdataGetFeasibility (SCIP *scip, SCIP_CONSDATA *consdata, SCIP_SOL *sol)
static void	consdataUpdateSignatures (SCIP_CONSDATA *consdata, int pos)
static void	consdataCalcSignatures (SCIP_CONSDATA *consdata)
static	SCIP_DECL_SORTINDCOMP (consdataCompVar)
static	SCIP_DECL_SORTINDCOMP (consdataCompVarProp)
static void	permSortConsdata (SCIP_CONSDATA *consdata, int *perm, int nvars)
static SCIP_RETCODE	consdataSort (SCIP *scip, SCIP_CONSDATA *consdata)
static SCIP_RETCODE	chgLhs (SCIP *scip, SCIP_CONS *cons, SCIP_Real lhs)
static SCIP_RETCODE	chgRhs (SCIP *scip, SCIP_CONS *cons, SCIP_Real rhs)
static SCIP_RETCODE	addCoef (SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)
static SCIP_RETCODE	delCoefPos (SCIP *scip, SCIP_CONS *cons, int pos)
static SCIP_RETCODE	chgCoefPos (SCIP *scip, SCIP_CONS *cons, int pos, SCIP_Real newval)
static SCIP_RETCODE	scaleCons (SCIP *scip, SCIP_CONS *cons, SCIP_Real scalar)
static SCIP_RETCODE	performVarDeletions (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss)
static SCIP_RETCODE	normalizeCons (SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible)
static SCIP_RETCODE	mergeMultiples (SCIP *scip, SCIP_CONS *cons)
static SCIP_RETCODE	applyFixings (SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible)
static SCIP_RETCODE	addConflictBounds (SCIP *scip, SCIP_CONS *cons, SCIP_VAR *infervar, SCIP_BDCHGIDX *bdchgidx, int inferpos, SCIP_Bool reasonisrhs)
static SCIP_RETCODE	addConflictFixedVars (SCIP *scip, SCIP_CONS *cons, SCIP_VAR *infervar, SCIP_BDCHGIDX *bdchgidx, int inferpos)
static SCIP_RETCODE	addConflictReasonVars (SCIP *scip, SCIP_VAR **vars, int nvars, SCIP_VAR *var, SCIP_Real bound)
static SCIP_RETCODE	resolvePropagation (SCIP *scip, SCIP_CONS *cons, SCIP_VAR *infervar, INFERINFO inferinfo, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_RESULT *result)
static SCIP_RETCODE	analyzeConflict (SCIP *scip, SCIP_CONS *cons, SCIP_Bool reasonisrhs)
static SCIP_Bool	canTightenBounds (SCIP_CONS *cons)
static SCIP_RETCODE	tightenVarUb (SCIP *scip, SCIP_CONS *cons, int pos, PROPRULE proprule, SCIP_Real newub, SCIP_Real oldub, SCIP_Bool *cutoff, int *nchgbds, SCIP_Bool force)
static SCIP_RETCODE	tightenVarLb (SCIP *scip, SCIP_CONS *cons, int pos, PROPRULE proprule, SCIP_Real newlb, SCIP_Real oldlb, SCIP_Bool *cutoff, int *nchgbds, SCIP_Bool force)
static SCIP_RETCODE	tightenVarBoundsEasy (SCIP *scip, SCIP_CONS *cons, int pos, SCIP_Bool *cutoff, int *nchgbds, SCIP_Bool force)
static SCIP_RETCODE	analyzeConflictRangedRow (SCIP *scip, SCIP_CONS *cons, SCIP_VAR **vars, int nvars, SCIP_VAR *var, SCIP_Real bound)
static SCIP_RETCODE	rangedRowPropagation (SCIP *scip, SCIP_CONS *cons, SCIP_Bool *cutoff, int *nfixedvars, int *nchgbds, int *naddconss)
static SCIP_RETCODE	tightenVarBounds (SCIP *scip, SCIP_CONS *cons, int pos, SCIP_Bool *cutoff, int *nchgbds, SCIP_Bool force)
static SCIP_RETCODE	tightenBounds (SCIP *scip, SCIP_CONS *cons, SCIP_Real maxeasyactivitydelta, SCIP_Bool sortvars, SCIP_Bool *cutoff, int *nchgbds)
static SCIP_RETCODE	checkCons (SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool checklprows, SCIP_Bool checkrelmaxabs, SCIP_Bool *violated)
static SCIP_RETCODE	createRow (SCIP *scip, SCIP_CONS *cons)
static SCIP_RETCODE	addRelaxation (SCIP *scip, SCIP_CONS *cons, SCIP_Bool *cutoff)
static SCIP_RETCODE	addNlrow (SCIP *scip, SCIP_CONS *cons)
static SCIP_RETCODE	separateCons (SCIP *scip, SCIP_CONS *cons, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_SOL *sol, SCIP_Bool separatecards, SCIP_Bool separateall, int *ncuts, SCIP_Bool *cutoff)
static SCIP_RETCODE	propagateCons (SCIP *scip, SCIP_CONS *cons, SCIP_Bool tightenbounds, SCIP_Bool rangedrowpropagation, SCIP_Real maxeasyactivitydelta, SCIP_Bool sortvars, SCIP_Bool *cutoff, int *nchgbds)
static SCIP_RETCODE	fixVariables (SCIP *scip, SCIP_CONS *cons, SCIP_Bool *cutoff, int *nfixedvars)
static SCIP_RETCODE	extractCliques (SCIP *scip, SCIP_CONS *cons, SCIP_Real maxeasyactivitydelta, SCIP_Bool sortvars, int *nfixedvars, int *nchgbds, SCIP_Bool *cutoff)
static SCIP_RETCODE	tightenSides (SCIP *scip, SCIP_CONS *cons, int *nchgsides, SCIP_Bool *infeasible)
static SCIP_RETCODE	consdataTightenCoefs (SCIP *scip, SCIP_CONS *cons, int *nchgcoefs, int *nchgsides)
static SCIP_RETCODE	convertUnaryEquality (SCIP *scip, SCIP_CONS *cons, SCIP_Bool *cutoff, int *nfixedvars, int *ndelconss)
static SCIP_RETCODE	convertBinaryEquality (SCIP *scip, SCIP_CONS *cons, SCIP_Bool *cutoff, int *naggrvars, int *ndelconss)
static void	getNewSidesAfterAggregation (SCIP *scip, SCIP_CONSDATA *consdata, SCIP_VAR *slackvar, SCIP_Real slackcoef, SCIP_Real *newlhs, SCIP_Real *newrhs)
static SCIP_RETCODE	convertLongEquality (SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_CONS *cons, SCIP_Bool *cutoff, int *naggrvars, int *ndelconss, int *nchgvartypes)
static SCIP_Bool	checkEqualObjective (SCIP *scip, SCIP_CONSDATA *consdata, SCIP_Real *scale, SCIP_Real *offset)
static SCIP_RETCODE	checkPartialObjective (SCIP *scip, SCIP_CONS *cons, SCIP_CONSHDLRDATA *conshdlrdata)
static SCIP_RETCODE	updateCutoffbound (SCIP *scip, SCIP_CONS *cons, SCIP_Real primalbound)
static SCIP_RETCODE	checkParallelObjective (SCIP *scip, SCIP_CONS *cons, SCIP_CONSHDLRDATA *conshdlrdata)
static SCIP_RETCODE	convertEquality (SCIP *scip, SCIP_CONS *cons, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_Bool *cutoff, int *nfixedvars, int *naggrvars, int *ndelconss, int *nchgvartypes)
static SCIP_Bool	consdataIsResidualIntegral (SCIP *scip, SCIP_CONSDATA *consdata, int pos, SCIP_Real val)
static void	calculateMinvalAndMaxval (SCIP *scip, SCIP_Real side, SCIP_Real val, SCIP_Real minresactivity, SCIP_Real maxresactivity, SCIP_Real *minval, SCIP_Real *maxval)
static SCIP_RETCODE	dualPresolve (SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_CONS *cons, SCIP_Bool *cutoff, int *nfixedvars, int *naggrvars, int *ndelconss, int *nchgvartypes)
static int	getVarWeight (SCIP_VAR *var)
static SCIP_RETCODE	aggregateVariables (SCIP *scip, SCIP_CONS *cons, SCIP_Bool *cutoff, int *nfixedvars, int *naggrvars)
static	SCIP_DECL_SORTINDCOMP (consdataCompSim)
static SCIP_RETCODE	rangedRowSimplify (SCIP *scip, SCIP_CONS *cons, int *nchgcoefs, int *nchgsides)
static SCIP_RETCODE	simplifyInequalities (SCIP *scip, SCIP_CONS *cons, int *nchgcoefs, int *nchgsides, SCIP_Bool *infeasible)
static SCIP_RETCODE	aggregateConstraints (SCIP *scip, SCIP_CONS *cons0, SCIP_CONS *cons1, int *commonidx0, int *commonidx1, int *diffidx0minus1, int *diffidx1minus0, int nvarscommon, int commonidxweight, int diffidx0minus1weight, int diffidx1minus0weight, SCIP_Real maxaggrnormscale, int *nchgcoefs, SCIP_Bool *aggregated, SCIP_Bool *infeasible)
static	SCIP_DECL_HASHGETKEY (hashGetKeyLinearcons)
static	SCIP_DECL_HASHKEYEQ (hashKeyEqLinearcons)
static	SCIP_DECL_HASHKEYVAL (hashKeyValLinearcons)
static unsigned int	getParallelConsKey (SCIP_CONS *cons)
static SCIP_RETCODE	retrieveParallelConstraints (SCIP_HASHTABLE *hashtable, SCIP_CONS **querycons, SCIP_CONS **parallelconss, int *nparallelconss)
static SCIP_RETCODE	detectRedundantConstraints (SCIP *scip, BMS_BLKMEM *blkmem, SCIP_CONS **conss, int nconss, int *firstchange, SCIP_Bool *cutoff, int *ndelconss, int *nchgsides)
static SCIP_RETCODE	preprocessConstraintPairs (SCIP *scip, SCIP_CONS **conss, int firstchange, int chkind, SCIP_Real maxaggrnormscale, SCIP_Bool *cutoff, int *ndelconss, int *nchgsides, int *nchgcoefs)
static SCIP_RETCODE	presolStuffing (SCIP *scip, SCIP_CONS *cons, SCIP_Bool singletonstuffing, SCIP_Bool singlevarstuffing, SCIP_Bool *cutoff, int *nfixedvars, int *nchgbds)
static SCIP_RETCODE	fullDualPresolve (SCIP *scip, SCIP_CONS **conss, int nconss, SCIP_Bool *cutoff, int *nchgbds, int *nchgvartypes)
static SCIP_RETCODE	enforceConstraint (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, int nusefulconss, SCIP_SOL *sol, SCIP_RESULT *result)
static SCIP_RETCODE	addSymmetryInformation (SCIP *scip, SYM_SYMTYPE symtype, SCIP_CONS *cons, SYM_GRAPH *graph, SCIP_Bool *success)
static	SCIP_DECL_CONSHDLRCOPY (conshdlrCopyLinear)
static	SCIP_DECL_CONSFREE (consFreeLinear)
static	SCIP_DECL_CONSINIT (consInitLinear)
static	SCIP_DECL_CONSEXIT (consExitLinear)
static SCIP_Bool	isRangedRow (SCIP *scip, SCIP_Real lhs, SCIP_Real rhs)
static SCIP_Bool	isFiniteNonnegativeIntegral (SCIP *scip, SCIP_Real x)
SCIP_RETCODE	SCIPclassifyConstraintTypesLinear (SCIP *scip, SCIP_LINCONSSTATS *linconsstats)
static	SCIP_DECL_CONSEXITPRE (consExitpreLinear)
static	SCIP_DECL_CONSINITSOL (consInitsolLinear)
static	SCIP_DECL_CONSEXITSOL (consExitsolLinear)
static	SCIP_DECL_CONSACTIVE (consActiveLinear)
static	SCIP_DECL_CONSDEACTIVE (consDeactiveLinear)
static	SCIP_DECL_CONSDELETE (consDeleteLinear)
static	SCIP_DECL_CONSTRANS (consTransLinear)
static	SCIP_DECL_CONSINITLP (consInitlpLinear)
static	SCIP_DECL_CONSSEPALP (consSepalpLinear)
static	SCIP_DECL_CONSSEPASOL (consSepasolLinear)
static	SCIP_DECL_CONSENFOLP (consEnfolpLinear)
static	SCIP_DECL_CONSENFORELAX (consEnforelaxLinear)
static	SCIP_DECL_CONSENFOPS (consEnfopsLinear)
static	SCIP_DECL_CONSCHECK (consCheckLinear)
static	SCIP_DECL_CONSPROP (consPropLinear)
static	SCIP_DECL_CONSPRESOL (consPresolLinear)
static	SCIP_DECL_CONSRESPROP (consRespropLinear)
static	SCIP_DECL_CONSLOCK (consLockLinear)
static	SCIP_DECL_CONSDELVARS (consDelvarsLinear)
static	SCIP_DECL_CONSPRINT (consPrintLinear)
static	SCIP_DECL_CONSCOPY (consCopyLinear)
static void	findOperators (const char *str, char **firstoperator, char **secondoperator, SCIP_Bool *success)
static	SCIP_DECL_CONSPARSE (consParseLinear)
static	SCIP_DECL_CONSGETVARS (consGetVarsLinear)
static	SCIP_DECL_CONSGETNVARS (consGetNVarsLinear)
static	SCIP_DECL_CONSGETPERMSYMGRAPH (consGetPermsymGraphLinear)
static	SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH (consGetSignedPermsymGraphLinear)
static	SCIP_DECL_EVENTEXEC (eventExecLinear)
static	SCIP_DECL_CONFLICTEXEC (conflictExecLinear)
static	SCIP_DECL_NONLINCONSUPGD (upgradeConsNonlinear)
SCIP_RETCODE	SCIPincludeConshdlrLinear (SCIP *scip)
SCIP_RETCODE	SCIPincludeLinconsUpgrade (SCIP *scip, SCIP_DECL_LINCONSUPGD((*linconsupgd)), int priority, const char *conshdlrname)
SCIP_RETCODE	SCIPcreateConsLinear (SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
SCIP_RETCODE	SCIPcreateConsBasicLinear (SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs)
SCIP_RETCODE	SCIPcopyConsLinear (SCIP *scip, SCIP_CONS **cons, SCIP *sourcescip, const char *name, int nvars, SCIP_VAR **sourcevars, SCIP_Real *sourcecoefs, SCIP_Real lhs, SCIP_Real rhs, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode, SCIP_Bool global, SCIP_Bool *valid)
SCIP_RETCODE	SCIPaddCoefLinear (SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE	SCIPchgCoefLinear (SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE	SCIPdelCoefLinear (SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)
SCIP_Real	SCIPgetLhsLinear (SCIP *scip, SCIP_CONS *cons)
SCIP_Real	SCIPgetRhsLinear (SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE	SCIPchgLhsLinear (SCIP *scip, SCIP_CONS *cons, SCIP_Real lhs)
SCIP_RETCODE	SCIPchgRhsLinear (SCIP *scip, SCIP_CONS *cons, SCIP_Real rhs)
int	SCIPgetNVarsLinear (SCIP *scip, SCIP_CONS *cons)
SCIP_VAR **	SCIPgetVarsLinear (SCIP *scip, SCIP_CONS *cons)
SCIP_Real *	SCIPgetValsLinear (SCIP *scip, SCIP_CONS *cons)
SCIP_Real	SCIPgetActivityLinear (SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol)
SCIP_Real	SCIPgetFeasibilityLinear (SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol)
SCIP_Real	SCIPgetDualsolLinear (SCIP *scip, SCIP_CONS *cons)
SCIP_Real	SCIPgetDualfarkasLinear (SCIP *scip, SCIP_CONS *cons)
SCIP_ROW *	SCIPgetRowLinear (SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE	SCIPcreateRowLinear (SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE	SCIPupgradeConsLinear (SCIP *scip, SCIP_CONS *cons, SCIP_CONS **upgdcons)
SCIP_RETCODE	SCIPcleanupConssLinear (SCIP *scip, SCIP_Bool onlychecked, SCIP_Bool *infeasible, int *ndelconss)

Macro Definition Documentation

CONSHDLR_NAME

#define CONSHDLR_NAME   "linear"

Definition at line 95 of file cons_linear.c.

CONSHDLR_DESC

#define CONSHDLR_DESC   "linear constraints of the form lhs <= a^T x <= rhs"

Definition at line 96 of file cons_linear.c.

CONSHDLR_SEPAPRIORITY

#define CONSHDLR_SEPAPRIORITY   +100000

priority of the constraint handler for separation

Definition at line 97 of file cons_linear.c.

CONSHDLR_ENFOPRIORITY

#define CONSHDLR_ENFOPRIORITY   -1000000

priority of the constraint handler for constraint enforcing

Definition at line 98 of file cons_linear.c.

CONSHDLR_CHECKPRIORITY

#define CONSHDLR_CHECKPRIORITY   -1000000

priority of the constraint handler for checking feasibility

Definition at line 99 of file cons_linear.c.

CONSHDLR_SEPAFREQ

#define CONSHDLR_SEPAFREQ   0

frequency for separating cuts; zero means to separate only in the root node

Definition at line 100 of file cons_linear.c.

CONSHDLR_PROPFREQ

#define CONSHDLR_PROPFREQ   1

frequency for propagating domains; zero means only preprocessing propagation

Definition at line 101 of file cons_linear.c.

CONSHDLR_EAGERFREQ

#define CONSHDLR_EAGERFREQ   100

frequency for using all instead of only the useful constraints in separation, propagation and enforcement, -1 for no eager evaluations, 0 for first only

Definition at line 103 of file cons_linear.c.

CONSHDLR_MAXPREROUNDS

#define CONSHDLR_MAXPREROUNDS   -1

maximal number of presolving rounds the constraint handler participates in (-1: no limit)

Definition at line 104 of file cons_linear.c.

CONSHDLR_DELAYSEPA

#define CONSHDLR_DELAYSEPA   FALSE

should separation method be delayed, if other separators found cuts?

Definition at line 105 of file cons_linear.c.

CONSHDLR_DELAYPROP

#define CONSHDLR_DELAYPROP   FALSE

should propagation method be delayed, if other propagators found reductions?

Definition at line 106 of file cons_linear.c.

CONSHDLR_NEEDSCONS

#define CONSHDLR_NEEDSCONS   TRUE

should the constraint handler be skipped, if no constraints are available?

Definition at line 107 of file cons_linear.c.

CONSHDLR_PRESOLTIMING

#define CONSHDLR_PRESOLTIMING   (SCIP_PRESOLTIMING_FAST | SCIP_PRESOLTIMING_EXHAUSTIVE)

presolving timing of the constraint handler (fast, medium, or exhaustive)

Definition at line 109 of file cons_linear.c.

CONSHDLR_PROP_TIMING

#define CONSHDLR_PROP_TIMING   SCIP_PROPTIMING_BEFORELP

Definition at line 110 of file cons_linear.c.

EVENTHDLR_NAME

#define EVENTHDLR_NAME   "linear"

Definition at line 112 of file cons_linear.c.

EVENTHDLR_DESC

#define EVENTHDLR_DESC   "bound change event handler for linear constraints"

Definition at line 113 of file cons_linear.c.

CONFLICTHDLR_NAME

#define CONFLICTHDLR_NAME   "linear"

Definition at line 115 of file cons_linear.c.

CONFLICTHDLR_DESC

#define CONFLICTHDLR_DESC   "conflict handler creating linear constraints"

Definition at line 116 of file cons_linear.c.

CONFLICTHDLR_PRIORITY

#define CONFLICTHDLR_PRIORITY   -1000000

Definition at line 117 of file cons_linear.c.

DEFAULT_TIGHTENBOUNDSFREQ

#define DEFAULT_TIGHTENBOUNDSFREQ   1

multiplier on propagation frequency, how often the bounds are tightened

Definition at line 119 of file cons_linear.c.

DEFAULT_MAXROUNDS

#define DEFAULT_MAXROUNDS   5

maximal number of separation rounds per node (-1: unlimited)

Definition at line 120 of file cons_linear.c.

DEFAULT_MAXROUNDSROOT

#define DEFAULT_MAXROUNDSROOT   -1

maximal number of separation rounds in the root node (-1: unlimited)

Definition at line 121 of file cons_linear.c.

DEFAULT_MAXSEPACUTS

#define DEFAULT_MAXSEPACUTS   50

maximal number of cuts separated per separation round

Definition at line 122 of file cons_linear.c.

DEFAULT_MAXSEPACUTSROOT

#define DEFAULT_MAXSEPACUTSROOT   200

maximal number of cuts separated per separation round in root node

Definition at line 123 of file cons_linear.c.

DEFAULT_PRESOLPAIRWISE

#define DEFAULT_PRESOLPAIRWISE   TRUE

should pairwise constraint comparison be performed in presolving?

Definition at line 124 of file cons_linear.c.

DEFAULT_PRESOLUSEHASHING

#define DEFAULT_PRESOLUSEHASHING   TRUE

should hash table be used for detecting redundant constraints in advance

Definition at line 125 of file cons_linear.c.

DEFAULT_NMINCOMPARISONS

#define DEFAULT_NMINCOMPARISONS   200000

number for minimal pairwise presolving comparisons

Definition at line 126 of file cons_linear.c.

DEFAULT_MINGAINPERNMINCOMP

#define DEFAULT_MINGAINPERNMINCOMP   1e-06

minimal gain per minimal pairwise presolving comparisons to repeat pairwise comparison round

Definition at line 128 of file cons_linear.c.

DEFAULT_SORTVARS

#define DEFAULT_SORTVARS   TRUE

should variables be sorted after presolve w.r.t their coefficient absolute for faster propagation?

Definition at line 130 of file cons_linear.c.

DEFAULT_CHECKRELMAXABS

#define DEFAULT_CHECKRELMAXABS   FALSE

should the violation for a constraint with side 0.0 be checked relative to 1.0 (FALSE) or to the maximum absolute value in the activity (TRUE)?

Definition at line 132 of file cons_linear.c.

DEFAULT_MAXAGGRNORMSCALE

#define DEFAULT_MAXAGGRNORMSCALE   0.0

maximal allowed relative gain in maximum norm for constraint aggregation (0.0: disable constraint aggregation)

Definition at line 134 of file cons_linear.c.

DEFAULT_MAXEASYACTIVITYDELTA

#define DEFAULT_MAXEASYACTIVITYDELTA   1e6

maximum activity delta to run easy propagation on linear constraint (faster, but numerically less stable)

Definition at line 136 of file cons_linear.c.

DEFAULT_MAXCARDBOUNDDIST

#define DEFAULT_MAXCARDBOUNDDIST   0.0

maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for separating knapsack cardinality cuts

Definition at line 138 of file cons_linear.c.

DEFAULT_SEPARATEALL

#define DEFAULT_SEPARATEALL   FALSE

should all constraints be subject to cardinality cut generation instead of only the ones with non-zero dual value?

Definition at line 140 of file cons_linear.c.

DEFAULT_AGGREGATEVARIABLES

#define DEFAULT_AGGREGATEVARIABLES   TRUE

should presolving search for redundant variables in equations

Definition at line 141 of file cons_linear.c.

DEFAULT_SIMPLIFYINEQUALITIES

#define DEFAULT_SIMPLIFYINEQUALITIES   TRUE

should presolving try to simplify inequalities

Definition at line 142 of file cons_linear.c.

DEFAULT_DUALPRESOLVING

#define DEFAULT_DUALPRESOLVING   TRUE

should dual presolving steps be performed?

Definition at line 143 of file cons_linear.c.

DEFAULT_SINGLETONSTUFFING

#define DEFAULT_SINGLETONSTUFFING   TRUE

should stuffing of singleton continuous variables be performed?

Definition at line 144 of file cons_linear.c.

DEFAULT_SINGLEVARSTUFFING

#define DEFAULT_SINGLEVARSTUFFING   FALSE

should single variable stuffing be performed, which tries to fulfill constraints using the cheapest variable?

Definition at line 146 of file cons_linear.c.

DEFAULT_DETECTCUTOFFBOUND

#define DEFAULT_DETECTCUTOFFBOUND   TRUE

should presolving try to detect constraints parallel to the objective function defining an upper bound and prevent these constraints from entering the LP

Definition at line 149 of file cons_linear.c.

DEFAULT_DETECTLOWERBOUND

#define DEFAULT_DETECTLOWERBOUND   TRUE

should presolving try to detect constraints parallel to the objective function defining a lower bound and prevent these constraints from entering the LP

Definition at line 152 of file cons_linear.c.

DEFAULT_DETECTPARTIALOBJECTIVE

#define DEFAULT_DETECTPARTIALOBJECTIVE   TRUE

should presolving try to detect subsets of constraints parallel to the objective function

Definition at line 154 of file cons_linear.c.

DEFAULT_RANGEDROWPROPAGATION

#define DEFAULT_RANGEDROWPROPAGATION   TRUE

should we perform ranged row propagation

Definition at line 155 of file cons_linear.c.

DEFAULT_RANGEDROWARTCONS

#define DEFAULT_RANGEDROWARTCONS   TRUE

should presolving and propagation extract sub-constraints from ranged rows and equations?

Definition at line 156 of file cons_linear.c.

DEFAULT_RANGEDROWMAXDEPTH

#define DEFAULT_RANGEDROWMAXDEPTH   INT_MAX

maximum depth to apply ranged row propagation

Definition at line 157 of file cons_linear.c.

DEFAULT_RANGEDROWFREQ

#define DEFAULT_RANGEDROWFREQ   1

frequency for applying ranged row propagation

Definition at line 158 of file cons_linear.c.

DEFAULT_MULTAGGRREMOVE

#define DEFAULT_MULTAGGRREMOVE   FALSE

should multi-aggregations only be performed if the constraint can be removed afterwards?

Definition at line 161 of file cons_linear.c.

DEFAULT_MAXMULTAGGRQUOT

#define DEFAULT_MAXMULTAGGRQUOT   1e+03

maximum coefficient dynamism (ie. maxabsval / minabsval) for multiaggregation

Definition at line 162 of file cons_linear.c.

DEFAULT_MAXDUALMULTAGGRQUOT

#define DEFAULT_MAXDUALMULTAGGRQUOT   1e+20

maximum coefficient dynamism (ie. maxabsval / minabsval) for multiaggregation

Definition at line 163 of file cons_linear.c.

DEFAULT_EXTRACTCLIQUES

#define DEFAULT_EXTRACTCLIQUES   TRUE

should cliques be extracted?

Definition at line 164 of file cons_linear.c.

MAXDNOM

#define MAXDNOM   10000LL

maximal denominator for simple rational fixed values

Definition at line 166 of file cons_linear.c.

MAXSCALEDCOEF

#define MAXSCALEDCOEF   0

maximal coefficient value after scaling

Definition at line 167 of file cons_linear.c.

MAXSCALEDCOEFINTEGER

#define MAXSCALEDCOEFINTEGER   0

maximal coefficient value after scaling if all variables are of integral type

Definition at line 170 of file cons_linear.c.

MAXACTVAL

#define MAXACTVAL   1e+09

maximal absolute value of full and partial activities such that redundancy-based simplifications are allowed to be applied

Definition at line 173 of file cons_linear.c.

MAXVALRECOMP

#define MAXVALRECOMP   1e+06

maximal abolsute value we trust without recomputing the activity

Definition at line 175 of file cons_linear.c.

MINVALRECOMP

#define MINVALRECOMP   1e-05

minimal abolsute value we trust without recomputing the activity

Definition at line 176 of file cons_linear.c.

NONLINCONSUPGD_PRIORITY

#define NONLINCONSUPGD_PRIORITY   1000000

priority of the constraint handler for upgrading of expressions constraints

Definition at line 179 of file cons_linear.c.

checkMaxActivityDelta

#define checkMaxActivityDelta	(		scip,
			consdata
	)

Definition at line 1537 of file cons_linear.c.

MAXTIGHTENROUNDS

#define MAXTIGHTENROUNDS   10

Definition at line 6973 of file cons_linear.c.

MAX_CLIQUE_NONZEROS_PER_CONS

#define MAX_CLIQUE_NONZEROS_PER_CONS   1000000

Definition at line 7844 of file cons_linear.c.

BINWEIGHT

#define BINWEIGHT   1

Definition at line 10978 of file cons_linear.c.

INTWEIGHT

#define INTWEIGHT   4

Definition at line 10979 of file cons_linear.c.

CONTWEIGHT

#define CONTWEIGHT   8

Definition at line 10980 of file cons_linear.c.

MAXCONSPRESOLROUNDS

#define MAXCONSPRESOLROUNDS   10

Definition at line 16192 of file cons_linear.c.

Typedef Documentation

PROPRULE

typedef enum Proprule PROPRULE

Definition at line 354 of file cons_linear.c.

INFERINFO

typedef struct InferInfo INFERINFO

Definition at line 369 of file cons_linear.c.

Enumeration Type Documentation

Proprule

enum Proprule

Enumerator
PROPRULE_INVALID	propagation was applied without a specific propagation rule
PROPRULE_1	v_i = FALSE => r = FALSE
PROPRULE_2	r = TRUE => v_i = TRUE for all i
PROPRULE_3	v_i = TRUE for all i => r = TRUE
PROPRULE_4	r = FALSE, v_i = TRUE for all i except j => v_j = FALSE
PROPRULE_0_INVALID	invalid inference information
PROPRULE_1_CORETIMES	core-time propagator
PROPRULE_2_EDGEFINDING	edge-finder
PROPRULE_3_TTEF	time-table edeg-finding
PROPRULE_1_RHS	activity residuals of all other variables tighten bounds of single variable due to the right hand side of the inequality
PROPRULE_1_LHS	activity residuals of all other variables tighten bounds of single variable due to the left hand side of the inequality
PROPRULE_1_RANGEDROW	fixed variables and gcd of all left variables tighten bounds of a single variable in this reanged row
PROPRULE_INVALID	propagation was applied without a specific propagation rule
PROPRULE_1_RHS	activity residuals of all other variables tighten bounds of single variable due to the right hand side of the inequality
PROPRULE_1_LHS	activity residuals of all other variables tighten bounds of single variable due to the left hand side of the inequality
PROPRULE_1_RANGEDROW	fixed variables and gcd of all left variables tighten bounds of a single variable in this reanged row
PROPRULE_INVALID	propagation was applied without a specific propagation rule
PROPRULE_1	v_i = TRUE => r = TRUE
PROPRULE_2	r = FALSE => v_i = FALSE for all i
PROPRULE_3	v_i = FALSE for all i => r = FALSE
PROPRULE_4	r = TRUE, v_i = FALSE for all i except j => v_j = TRUE
PROPRULE_INVALID	propagation was applied without a specific propagation rule
PROPRULE_1	left hand side and bounds on y -> lower bound on x
PROPRULE_2	left hand side and upper bound on x -> bound on y
PROPRULE_3	right hand side and bounds on y -> upper bound on x
PROPRULE_4	right hand side and lower bound on x -> bound on y
PROPRULE_0	all variables are fixed => fix integral variable
PROPRULE_1	all except one variable fixed => fix remaining variable
PROPRULE_INTLB	lower bound propagation of integral variable
PROPRULE_INTUB	upper bound propagation of integral variable
PROPRULE_INVALID	propagation was applied without a specific propagation rule

Definition at line 344 of file cons_linear.c.

Function Documentation

intToInferInfo()

static INFERINFO intToInferInfo ( int  i )

static

converts an integer into an inference information

Parameters

i	integer to convert

Definition at line 373 of file cons_linear.c.

Referenced by SCIP_DECL_CONSRESPROP().

inferInfoToInt()

static int inferInfoToInt ( INFERINFO  inferinfo )

static

converts an inference information into an int

Parameters

inferinfo

inference information to convert

Definition at line 386 of file cons_linear.c.

Referenced by getInferInt().

inferInfoGetProprule()

static int inferInfoGetProprule ( INFERINFO  inferinfo )

static

returns the propagation rule stored in the inference information

Parameters

inferinfo

inference information to convert

Definition at line 395 of file cons_linear.c.

Referenced by resolvePropagation().

inferInfoGetPos()

static int inferInfoGetPos ( INFERINFO  inferinfo )

static

returns the position stored in the inference information

Parameters

inferinfo

inference information to convert

Definition at line 404 of file cons_linear.c.

Referenced by resolvePropagation().

getInferInfo()

static INFERINFO getInferInfo ( PROPRULE  proprule, int  pos  )

static

constructs an inference information out of a propagation rule and a position number

Parameters

proprule	propagation rule that deduced the value
pos	variable position, the propagation rule was applied at

Definition at line 413 of file cons_linear.c.

Referenced by getInferInt().

getInferInt()

static int getInferInt ( PROPRULE  proprule, int  pos  )

static

constructs an inference information out of a propagation rule and a position number, returns info as int

Parameters

proprule	propagation rule that deduced the value
pos	variable position, the propagation rule was applied at

Definition at line 432 of file cons_linear.c.

References getInferInfo(), and inferInfoToInt().

Referenced by rangedRowPropagation(), tightenVarBounds(), tightenVarLb(), and tightenVarUb().

conshdlrdataEnsureLinconsupgradesSize()

static SCIP_RETCODE conshdlrdataEnsureLinconsupgradesSize ( SCIP *  scip, SCIP_CONSHDLRDATA *  conshdlrdata, int  num  )

static

ensures, that linconsupgrades array can store at least num entries

Parameters

scip	SCIP data structure
conshdlrdata	linear constraint handler data
num	minimum number of entries to store

Definition at line 447 of file cons_linear.c.

References NULL, SCIP_CALL, SCIP_OKAY, SCIPcalcMemGrowSize(), and SCIPreallocBlockMemoryArray.

Referenced by conshdlrdataIncludeUpgrade().

consdataEnsureVarsSize()

static SCIP_RETCODE consdataEnsureVarsSize ( SCIP *  scip, SCIP_CONSDATA *  consdata, int  num  )

static

ensures, that vars and vals arrays can store at least num entries

Parameters

scip	SCIP data structure
consdata	linear constraint data
num	minimum number of entries to store

Definition at line 472 of file cons_linear.c.

References NULL, SCIP_CALL, SCIP_OKAY, SCIPcalcMemGrowSize(), and SCIPreallocBlockMemoryArray.

Referenced by addCoef(), and SCIP_DECL_NONLINCONSUPGD().

linconsupgradeCreate()

static SCIP_RETCODE linconsupgradeCreate ( SCIP *  scip, SCIP_LINCONSUPGRADE **  linconsupgrade, SCIP_DECL_LINCONSUPGD((*linconsupgd))  , int  priority  )

static

creates a linear constraint upgrade data object

Parameters

scip	SCIP data structure
linconsupgrade	pointer to store the linear constraint upgrade
priority	priority of upgrading method

Definition at line 507 of file cons_linear.c.

References NULL, SCIP_CALL, SCIP_OKAY, SCIPallocBlockMemory, and TRUE.

Referenced by SCIPincludeLinconsUpgrade().

linconsupgradeFree()

static void linconsupgradeFree ( SCIP *  scip, SCIP_LINCONSUPGRADE **  linconsupgrade  )

static

frees a linear constraint upgrade data object

Parameters

scip	SCIP data structure
linconsupgrade	pointer to the linear constraint upgrade

Definition at line 528 of file cons_linear.c.

References NULL, and SCIPfreeBlockMemory.

Referenced by conshdlrdataFree().

conshdlrdataCreate()

static SCIP_RETCODE conshdlrdataCreate ( SCIP *  scip, SCIP_CONSHDLRDATA **  conshdlrdata, SCIP_EVENTHDLR *  eventhdlr  )

static

creates constraint handler data for linear constraint handler

Parameters

scip	SCIP data structure
conshdlrdata	pointer to store the constraint handler data
eventhdlr	event handler

Definition at line 542 of file cons_linear.c.

References NULL, SCIP_CALL, SCIP_OKAY, and SCIPallocBlockMemory.

Referenced by SCIPincludeConshdlrLinear().

conshdlrdataFree()

static void conshdlrdataFree ( SCIP *  scip, SCIP_CONSHDLRDATA **  conshdlrdata  )

static

frees constraint handler data for linear constraint handler

Parameters

scip	SCIP data structure
conshdlrdata	pointer to the constraint handler data

Definition at line 566 of file cons_linear.c.

References linconsupgradeFree(), NULL, SCIPfreeBlockMemory, and SCIPfreeBlockMemoryArrayNull.

Referenced by SCIP_DECL_CONSFREE().

conshdlrdataHasUpgrade()

static SCIP_Bool conshdlrdataHasUpgrade ( SCIP *  scip, SCIP_CONSHDLRDATA *  conshdlrdata, SCIP_DECL_LINCONSUPGD((*linconsupgd))  , const char *  conshdlrname  )

static

creates a linear constraint upgrade data object

Parameters

scip	SCIP data structure
conshdlrdata	constraint handler data
conshdlrname	name of the constraint handler

Definition at line 588 of file cons_linear.c.

References FALSE, NULL, SCIPwarningMessage(), and TRUE.

Referenced by SCIPincludeLinconsUpgrade().

conshdlrdataIncludeUpgrade()

static SCIP_RETCODE conshdlrdataIncludeUpgrade ( SCIP *  scip, SCIP_CONSHDLRDATA *  conshdlrdata, SCIP_LINCONSUPGRADE *  linconsupgrade  )

static

adds a linear constraint update method to the constraint handler's data

Parameters

scip	SCIP data structure
conshdlrdata	constraint handler data
linconsupgrade	linear constraint upgrade method

Definition at line 618 of file cons_linear.c.

References conshdlrdataEnsureLinconsupgradesSize(), NULL, SCIP_LinConsUpgrade::priority, SCIP_CALL, and SCIP_OKAY.

Referenced by SCIPincludeLinconsUpgrade().

lockRounding()

static SCIP_RETCODE lockRounding ( SCIP *  scip, SCIP_CONS *  cons, SCIP_VAR *  var, SCIP_Real  val  )

static

installs rounding locks for the given variable associated to the given coefficient in the linear constraint

Parameters

scip	SCIP data structure
cons	linear constraint
var	variable of constraint entry
val	coefficient of constraint entry

Definition at line 650 of file cons_linear.c.

References NULL, SCIP_CALL, SCIP_OKAY, SCIPconsGetData(), SCIPisInfinity(), SCIPisZero(), and SCIPlockVarCons().

Referenced by addCoef(), and chgCoefPos().

unlockRounding()

static SCIP_RETCODE unlockRounding ( SCIP *  scip, SCIP_CONS *  cons, SCIP_VAR *  var, SCIP_Real  val  )

static

removes rounding locks for the given variable associated to the given coefficient in the linear constraint

Parameters

scip	SCIP data structure
cons	linear constraint
var	variable of constraint entry
val	coefficient of constraint entry

Definition at line 683 of file cons_linear.c.

References NULL, SCIP_CALL, SCIP_OKAY, SCIPconsGetData(), SCIPisInfinity(), SCIPisZero(), and SCIPunlockVarCons().

Referenced by chgCoefPos(), and delCoefPos().

consCatchEvent()

static SCIP_RETCODE consCatchEvent ( SCIP *  scip, SCIP_CONS *  cons, SCIP_EVENTHDLR *  eventhdlr, int  pos  )

static

creates event data for variable at given position, and catches events ! [SnippetDebugAssertions]

Parameters

scip	SCIP data structure
cons	linear constraint
eventhdlr	event handler to call for the event processing
pos	array position of variable to catch bound change events for

Definition at line 717 of file cons_linear.c.

References NULL, SCIP_CALL, SCIP_EVENTTYPE_BOUNDCHANGED, SCIP_EVENTTYPE_GBDCHANGED, SCIP_EVENTTYPE_IMPLTYPECHANGED, SCIP_EVENTTYPE_TYPECHANGED, SCIP_EVENTTYPE_VARDELETED, SCIP_EVENTTYPE_VARFIXED, SCIP_EVENTTYPE_VARUNLOCKED, SCIP_OKAY, SCIPallocBlockMemory, SCIPcatchVarEvent(), SCIPconsGetData(), SCIPvarIsActive(), and SCIPvarIsTransformed().

Referenced by addCoef(), and consCatchAllEvents().

consDropEvent()

static SCIP_RETCODE consDropEvent ( SCIP *  scip, SCIP_CONS *  cons, SCIP_EVENTHDLR *  eventhdlr, int  pos  )

static

! [SnippetDebugAssertions] deletes event data for variable at given position, and drops events

Parameters

scip	SCIP data structure
cons	linear constraint
eventhdlr	event handler to call for the event processing
pos	array position of variable to catch bound change events for

Definition at line 757 of file cons_linear.c.

References NULL, SCIP_CALL, SCIP_EVENTTYPE_BOUNDCHANGED, SCIP_EVENTTYPE_GBDCHANGED, SCIP_EVENTTYPE_IMPLTYPECHANGED, SCIP_EVENTTYPE_TYPECHANGED, SCIP_EVENTTYPE_VARDELETED, SCIP_EVENTTYPE_VARFIXED, SCIP_EVENTTYPE_VARUNLOCKED, SCIP_OKAY, SCIPconsGetData(), SCIPdropVarEvent(), and SCIPfreeBlockMemory.

Referenced by consDropAllEvents(), and delCoefPos().

consCatchAllEvents()

static SCIP_RETCODE consCatchAllEvents ( SCIP *  scip, SCIP_CONS *  cons, SCIP_EVENTHDLR *  eventhdlr  )

static

catches bound change events for all variables in transformed linear constraint

Parameters

scip	SCIP data structure
cons	linear constraint
eventhdlr	event handler to call for the event processing

Definition at line 792 of file cons_linear.c.

References BMSclearMemoryArray, consCatchEvent(), NULL, SCIP_CALL, SCIP_OKAY, SCIPallocBlockMemoryArray, and SCIPconsGetData().

Referenced by applyFixings(), propagateCons(), SCIP_DECL_CONSINIT(), and SCIP_DECL_CONSPRESOL().

consDropAllEvents()

static SCIP_RETCODE consDropAllEvents ( SCIP *  scip, SCIP_CONS *  cons, SCIP_EVENTHDLR *  eventhdlr  )

static

drops bound change events for all variables in transformed linear constraint

Parameters

scip	SCIP data structure
cons	linear constraint
eventhdlr	event handler to call for the event processing

Definition at line 824 of file cons_linear.c.

References consDropEvent(), NULL, SCIP_CALL, SCIP_OKAY, SCIPconsGetData(), and SCIPfreeBlockMemoryArray.

Referenced by SCIP_DECL_CONSDEACTIVE(), SCIP_DECL_CONSDELETE(), and SCIP_DECL_CONSEXIT().

consdataCreate()

static SCIP_RETCODE consdataCreate ( SCIP *  scip, SCIP_CONSDATA **  consdata, int  nvars, SCIP_VAR **  vars, SCIP_Real *  vals, SCIP_Real  lhs, SCIP_Real  rhs  )

static

creates a linear constraint data

Parameters

scip	SCIP data structure
consdata	pointer to linear constraint data
nvars	number of nonzeros in the constraint
vars	array with variables of constraint entries
vals	array with coefficients of constraint entries
lhs	left hand side of row
rhs	right hand side of row

Definition at line 855 of file cons_linear.c.

References FALSE, NULL, QUAD_ASSIGN, REALABS, SCIP_CALL, SCIP_INVALID, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_Real, SCIPallocBlockMemory, SCIPallocBufferArray, SCIPcaptureVar(), SCIPduplicateBlockMemoryArray, SCIPfreeBlockMemory, SCIPfreeBlockMemoryArrayNull, SCIPfreeBufferArray, SCIPgetTransformedVars(), SCIPinfinity(), SCIPisConsCompressionEnabled(), SCIPisEQ(), SCIPisGT(), SCIPisInfinity(), SCIPisTransformed(), SCIPisZero(), SCIPvarGetLbGlobal(), SCIPvarGetUbGlobal(), SCIPvarIsBinary(), SCIPvarIsIntegral(), SCIPwarningMessage(), and TRUE.

Referenced by SCIP_DECL_CONSTRANS(), and SCIPcreateConsLinear().

consdataFree()

static SCIP_RETCODE consdataFree ( SCIP *  scip, SCIP_CONSDATA **  consdata  )

static

frees a linear constraint data

Parameters

scip	SCIP data structure
consdata	pointer to linear constraint data

Definition at line 1056 of file cons_linear.c.

References NULL, SCIP_CALL, SCIP_OKAY, SCIPfreeBlockMemory, SCIPfreeBlockMemoryArrayNull, SCIPisZero(), SCIPreleaseNlRow(), SCIPreleaseRow(), and SCIPreleaseVar().

Referenced by SCIP_DECL_CONSDELETE().

consdataPrint()

static SCIP_RETCODE consdataPrint ( SCIP *  scip, SCIP_CONSDATA *  consdata, FILE *  file  )

static

prints linear constraint in CIP format to file stream

Parameters

scip	SCIP data structure
consdata	linear constraint data
file	output file (or NULL for standard output)

Definition at line 1097 of file cons_linear.c.

References NULL, SCIP_CALL, SCIP_OKAY, SCIPinfoMessage(), SCIPisEQ(), SCIPisInfinity(), SCIPwriteVarsLinearsum(), and TRUE.

Referenced by SCIP_DECL_CONSPRINT().

consPrintConsSol()

static SCIP_RETCODE consPrintConsSol ( SCIP *  scip, SCIP_CONS *  cons, SCIP_SOL *  sol, FILE *  file  )

static

prints linear constraint and contained solution values of variables to file stream

Parameters

scip	SCIP data structure
cons	linear constraint
sol	solution to print
file	output file (or NULL for standard output)

Definition at line 1136 of file cons_linear.c.

References NULL, SCIP_CALL, SCIP_OKAY, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconshdlrGetName(), SCIPgetMessagehdlr(), SCIPgetSolVal(), SCIPinfoMessage(), SCIPisEQ(), SCIPisInfinity(), SCIPmessageFPrintInfo(), SCIPwriteVarName(), and TRUE.

Referenced by checkCons(), and SCIP_DECL_CONSCHECK().

consdataInvalidateActivities()

static void consdataInvalidateActivities ( SCIP_CONSDATA *  consdata )

static

invalidates activity bounds, such that they are recalculated in next get

Parameters

consdata

linear constraint

Definition at line 1208 of file cons_linear.c.

References FALSE, NULL, QUAD_ASSIGN, and SCIP_INVALID.

Referenced by delCoefPos(), scaleCons(), and SCIP_DECL_EVENTEXEC().

consdataComputePseudoActivity()

static SCIP_Real consdataComputePseudoActivity ( SCIP *  scip, SCIP_CONSDATA *  consdata  )

static

compute the pseudo activity of a constraint

Parameters

scip	SCIP data structure
consdata	linear constraint data

Definition at line 1254 of file cons_linear.c.

References bound, SCIP_INVALID, SCIP_Real, SCIPinfinity(), SCIPisInfinity(), SCIPisZero(), and SCIPvarGetBestBoundLocal().

Referenced by checkCons(), and consdataGetActivity().

consdataRecomputeMinactivity()

static void consdataRecomputeMinactivity ( SCIP *  scip, SCIP_CONSDATA *  consdata  )

static

recompute the minactivity of a constraint

Parameters

scip	SCIP data structure
consdata	linear constraint data

Definition at line 1307 of file cons_linear.c.

References bound, QUAD_ASSIGN, QUAD_TO_DBL, SCIP_Real, SCIPisHugeValue(), SCIPisInfinity(), SCIPquadprecSumQD, SCIPvarGetLbLocal(), SCIPvarGetUbLocal(), and TRUE.

Referenced by getMinActivity(), SCIP_DECL_CONSPRESOL(), and tightenVarBoundsEasy().

consdataRecomputeMaxactivity()

static void consdataRecomputeMaxactivity ( SCIP *  scip, SCIP_CONSDATA *  consdata  )

static

recompute the maxactivity of a constraint

Parameters

scip	SCIP data structure
consdata	linear constraint data

Definition at line 1334 of file cons_linear.c.

References bound, QUAD_ASSIGN, QUAD_TO_DBL, SCIP_Real, SCIPisHugeValue(), SCIPisInfinity(), SCIPquadprecSumQD, SCIPvarGetLbLocal(), SCIPvarGetUbLocal(), and TRUE.

Referenced by getMaxActivity(), SCIP_DECL_CONSPRESOL(), and tightenVarBoundsEasy().

consdataRecomputeGlbMinactivity()

static void consdataRecomputeGlbMinactivity ( SCIP *  scip, SCIP_CONSDATA *  consdata  )

static

recompute the global minactivity of a constraint

Parameters

scip	SCIP data structure
consdata	linear constraint data

Definition at line 1361 of file cons_linear.c.

References bound, QUAD_ASSIGN, QUAD_TO_DBL, SCIP_Real, SCIPisHugeValue(), SCIPisInfinity(), SCIPquadprecSumQD, SCIPvarGetLbGlobal(), SCIPvarGetUbGlobal(), and TRUE.

Referenced by extractCliques(), and getMinActivity().

consdataRecomputeGlbMaxactivity()

static void consdataRecomputeGlbMaxactivity ( SCIP *  scip, SCIP_CONSDATA *  consdata  )

static

recompute the global maxactivity of a constraint

Parameters

scip	SCIP data structure
consdata	linear constraint data

Definition at line 1388 of file cons_linear.c.

References bound, QUAD_ASSIGN, QUAD_TO_DBL, SCIP_Real, SCIPisHugeValue(), SCIPisInfinity(), SCIPquadprecSumQD, SCIPvarGetLbGlobal(), SCIPvarGetUbGlobal(), and TRUE.

Referenced by extractCliques(), and getMaxActivity().

consdataCalcMaxAbsval()

static void consdataCalcMaxAbsval ( SCIP_CONSDATA *  consdata )

static

calculates maximum absolute value of coefficients

Parameters

consdata

linear constraint data

Definition at line 1415 of file cons_linear.c.

References NULL, REALABS, SCIP_INVALID, SCIP_Real, and TRUE.

Referenced by consdataGetMaxAbsval(), and normalizeCons().

consdataCalcMinAbsval()

static void consdataCalcMinAbsval ( SCIP_CONSDATA *  consdata )

static

calculates minimum absolute value of coefficients

Parameters

consdata

linear constraint data

Definition at line 1439 of file cons_linear.c.

References NULL, REALABS, SCIP_INVALID, SCIP_Real, and TRUE.

Referenced by consdataGetMinAbsval(), and normalizeCons().

consdataCheckNonbinvar()

static void consdataCheckNonbinvar ( SCIP_CONSDATA *  consdata )

static

checks the type of all variables of the constraint and sets hasnonbinvar and hascontvar flags accordingly

Parameters

consdata

linear constraint data

Definition at line 1468 of file cons_linear.c.

References FALSE, SCIPvarIsBinary(), SCIPvarIsIntegral(), and TRUE.

Referenced by consdataRecomputeMaxActivityDelta(), and normalizeCons().

consdataRecomputeMaxActivityDelta()

static void consdataRecomputeMaxActivityDelta ( SCIP *  scip, SCIP_CONSDATA *  consdata  )

static

recompute maximal activity contribution for a single variable

Parameters

scip	SCIP data structure
consdata	linear constraint data

Definition at line 1542 of file cons_linear.c.

References consdataCheckNonbinvar(), REALABS, SCIP_Real, SCIPinfinity(), SCIPisInfinity(), SCIPvarGetLbLocal(), and SCIPvarGetUbLocal().

Referenced by SCIP_DECL_CONSEXITPRE(), simplifyInequalities(), and tightenBounds().

consdataUpdateActivities()

static void consdataUpdateActivities ( SCIP *  scip, SCIP_CONSDATA *  consdata, SCIP_VAR *  var, SCIP_Real  oldbound, SCIP_Real  newbound, SCIP_Real  val, SCIP_BOUNDTYPE  boundtype, SCIP_Bool  global, SCIP_Bool  checkreliability  )

static

updates activities for a change in a bound

Parameters

scip	SCIP data structure
consdata	linear constraint data
var	variable that has been changed; can be NULL for global bound changes
oldbound	old bound of variable
newbound	new bound of variable
val	coefficient of constraint entry
boundtype	type of the bound change
global	is it a global or a local bound change?
checkreliability	should the reliability of the recalculated activity be checked?

Definition at line 1604 of file cons_linear.c.

References FALSE, NULL, QUAD_ASSIGN, QUAD_ASSIGN_Q, QUAD_MEMBER, QUAD_TO_DBL, REALABS, SCIP_Bool, SCIP_BOUNDTYPE_LOWER, SCIP_INVALID, SCIP_Real, SCIPdebugMsg, SCIPisHugeValue(), SCIPisInfinity(), SCIPisUpdateUnreliable(), and SCIPquadprecSumQD.

Referenced by consdataUpdateActivitiesGlbLb(), consdataUpdateActivitiesGlbUb(), consdataUpdateActivitiesLb(), and consdataUpdateActivitiesUb().

consdataUpdateActivitiesLb()

static void consdataUpdateActivitiesLb ( SCIP *  scip, SCIP_CONSDATA *  consdata, SCIP_VAR *  var, SCIP_Real  oldlb, SCIP_Real  newlb, SCIP_Real  val, SCIP_Bool  checkreliability  )

static

updates minimum and maximum activity for a change in lower bound

Parameters

scip	SCIP data structure
consdata	linear constraint data
var	variable that has been changed
oldlb	old lower bound of variable
newlb	new lower bound of variable
val	coefficient of constraint entry
checkreliability	should the reliability of the recalculated activity be checked?

Definition at line 1996 of file cons_linear.c.

References consdataUpdateActivities(), FALSE, NULL, QUAD_TO_DBL, SCIP_BOUNDTYPE_LOWER, and SCIPisInfinity().

Referenced by consdataUpdateAddCoef(), consdataUpdateDelCoef(), and SCIP_DECL_EVENTEXEC().

consdataUpdateActivitiesUb()

static void consdataUpdateActivitiesUb ( SCIP *  scip, SCIP_CONSDATA *  consdata, SCIP_VAR *  var, SCIP_Real  oldub, SCIP_Real  newub, SCIP_Real  val, SCIP_Bool  checkreliability  )

static

updates minimum and maximum activity for a change in upper bound

Parameters

scip	SCIP data structure
consdata	linear constraint data
var	variable that has been changed
oldub	old upper bound of variable
newub	new upper bound of variable
val	coefficient of constraint entry
checkreliability	should the reliability of the recalculated activity be checked?

Definition at line 2021 of file cons_linear.c.

References consdataUpdateActivities(), FALSE, NULL, QUAD_TO_DBL, SCIP_BOUNDTYPE_UPPER, and SCIPisInfinity().

Referenced by consdataUpdateAddCoef(), consdataUpdateDelCoef(), and SCIP_DECL_EVENTEXEC().

consdataUpdateActivitiesGlbLb()

static void consdataUpdateActivitiesGlbLb ( SCIP *  scip, SCIP_CONSDATA *  consdata, SCIP_Real  oldlb, SCIP_Real  newlb, SCIP_Real  val, SCIP_Bool  checkreliability  )

static

updates minimum and maximum global activity for a change in the global lower bound

Parameters

scip	SCIP data structure
consdata	linear constraint data
oldlb	old lower bound of variable
newlb	new lower bound of variable
val	coefficient of constraint entry
checkreliability	should the reliability of the recalculated activity be checked?

Definition at line 2046 of file cons_linear.c.

References consdataUpdateActivities(), NULL, QUAD_TO_DBL, SCIP_BOUNDTYPE_LOWER, SCIPisInfinity(), and TRUE.

Referenced by consdataUpdateAddCoef(), consdataUpdateDelCoef(), and SCIP_DECL_EVENTEXEC().

consdataUpdateActivitiesGlbUb()

static void consdataUpdateActivitiesGlbUb ( SCIP *  scip, SCIP_CONSDATA *  consdata, SCIP_Real  oldub, SCIP_Real  newub, SCIP_Real  val, SCIP_Bool  checkreliability  )

static

updates minimum and maximum global activity for a change in global upper bound

Parameters

scip	SCIP data structure
consdata	linear constraint data
oldub	old upper bound of variable
newub	new upper bound of variable
val	coefficient of constraint entry
checkreliability	should the reliability of the recalculated activity be checked?

Definition at line 2069 of file cons_linear.c.

References consdataUpdateActivities(), NULL, QUAD_TO_DBL, SCIP_BOUNDTYPE_UPPER, SCIPisInfinity(), and TRUE.

Referenced by consdataUpdateAddCoef(), consdataUpdateDelCoef(), and SCIP_DECL_EVENTEXEC().

consdataUpdateAddCoef()

static void consdataUpdateAddCoef ( SCIP *  scip, SCIP_CONSDATA *  consdata, SCIP_VAR *  var, SCIP_Real  val, SCIP_Bool  checkreliability  )

static

updates minimum and maximum activity and maximum absolute value for coefficient addition

Parameters

scip	SCIP data structure
consdata	linear constraint data
var	variable of constraint entry
val	coefficient of constraint entry
checkreliability	should the reliability of the recalculated activity be checked?

Definition at line 2092 of file cons_linear.c.

References consdataUpdateActivitiesGlbLb(), consdataUpdateActivitiesGlbUb(), consdataUpdateActivitiesLb(), consdataUpdateActivitiesUb(), MAX, MIN, NULL, QUAD_TO_DBL, REALABS, SCIP_INVALID, SCIP_Real, SCIPinfinity(), SCIPisInfinity(), SCIPisZero(), SCIPvarGetLbGlobal(), SCIPvarGetLbLocal(), SCIPvarGetUbGlobal(), and SCIPvarGetUbLocal().

Referenced by addCoef(), chgCoefPos(), consdataCalcActivities(), and consdataUpdateChgCoef().

consdataUpdateDelCoef()

static void consdataUpdateDelCoef ( SCIP *  scip, SCIP_CONSDATA *  consdata, SCIP_VAR *  var, SCIP_Real  val, SCIP_Bool  checkreliability  )

static

updates minimum and maximum activity for coefficient deletion, invalidates maximum absolute value if necessary

Parameters

scip	SCIP data structure
consdata	linear constraint data
var	variable of constraint entry
val	coefficient of constraint entry
checkreliability	should the reliability of the recalculated activity be checked?

Definition at line 2168 of file cons_linear.c.

References consdataUpdateActivitiesGlbLb(), consdataUpdateActivitiesGlbUb(), consdataUpdateActivitiesLb(), consdataUpdateActivitiesUb(), FALSE, NULL, QUAD_TO_DBL, REALABS, SCIP_INVALID, SCIP_Real, SCIPisEQ(), SCIPisZero(), SCIPvarGetLbGlobal(), SCIPvarGetLbLocal(), SCIPvarGetUbGlobal(), and SCIPvarGetUbLocal().

Referenced by chgCoefPos(), consdataUpdateChgCoef(), and delCoefPos().

consdataUpdateChgCoef()

static void consdataUpdateChgCoef ( SCIP *  scip, SCIP_CONSDATA *  consdata, SCIP_VAR *  var, SCIP_Real  oldval, SCIP_Real  newval, SCIP_Bool  checkreliability  )

static

updates minimum and maximum activity for coefficient change, invalidates maximum absolute value if necessary

Parameters

scip	SCIP data structure
consdata	linear constraint data
var	variable of constraint entry
oldval	old coefficient of constraint entry
newval	new coefficient of constraint entry
checkreliability	should the reliability of the recalculated activity be checked?

Definition at line 2233 of file cons_linear.c.

References consdataUpdateAddCoef(), and consdataUpdateDelCoef().

Referenced by chgCoefPos().

consdataGetMaxAbsval()

static SCIP_Real consdataGetMaxAbsval ( SCIP_CONSDATA *  consdata )

static

returns the maximum absolute value of all coefficients in the constraint

Parameters

consdata

linear constraint data

Definition at line 2249 of file cons_linear.c.

References consdataCalcMaxAbsval(), NULL, and SCIP_INVALID.

Referenced by aggregateConstraints(), normalizeCons(), and SCIP_DECL_HASHKEYEQ().

consdataGetMinAbsval()

static SCIP_Real consdataGetMinAbsval ( SCIP_CONSDATA *  consdata )

static

returns the minimum absolute value of all coefficients in the constraint

Parameters

consdata

linear constraint data

Definition at line 2265 of file cons_linear.c.

References consdataCalcMinAbsval(), NULL, and SCIP_INVALID.

Referenced by normalizeCons().

consdataCalcActivities()

static void consdataCalcActivities ( SCIP *  scip, SCIP_CONSDATA *  consdata  )

static

calculates minimum and maximum local and global activity for constraint from scratch; additionally recalculates maximum absolute value of coefficients

Parameters

scip	SCIP data structure
consdata	linear constraint data

Definition at line 2283 of file cons_linear.c.

References consdataUpdateAddCoef(), FALSE, NULL, QUAD_ASSIGN, QUAD_TO_DBL, REALABS, SCIP_INVALID, and TRUE.

Referenced by consdataGetActivityBounds(), consdataGetActivityResiduals(), consdataGetGlbActivityBounds(), consdataGetGlbActivityResiduals(), extractCliques(), and tightenVarBoundsEasy().

getMinActivity()

static void getMinActivity ( SCIP *  scip, SCIP_CONSDATA *  consdata, int  posinf, int  neginf, int  poshuge, int  neghuge, SCIP_Real  delta, SCIP_Bool  global, SCIP_Bool  goodrelax, SCIP_Real *  minactivity, SCIP_Bool *  istight, SCIP_Bool *  issettoinfinity  )

static

gets minimal activity for constraint and given values of counters for infinite and huge contributions and (if needed) delta to subtract from stored finite part of activity in case of a residual activity

Parameters

scip	SCIP data structure
consdata	linear constraint
posinf	number of coefficients contributing pos. infinite value
neginf	number of coefficients contributing neg. infinite value
poshuge	number of coefficients contributing huge pos. value
neghuge	number of coefficients contributing huge neg. value
delta	value to subtract from stored minactivity (contribution of the variable set to zero when getting residual activity)
global	should the global or local minimal activity be returned?
goodrelax	should a good relaxation be computed or are relaxed acticities ignored, anyway?
minactivity	pointer to store the minimal activity
istight	pointer to store whether activity bound is tight to variable bounds i.e. is the actual minactivity (otherwise a lower bound is provided)
issettoinfinity	pointer to store whether minactivity was set to infinity or calculated

Definition at line 2345 of file cons_linear.c.

References consdataRecomputeGlbMinactivity(), consdataRecomputeMinactivity(), FALSE, NULL, QUAD, QUAD_ASSIGN_Q, QUAD_TO_DBL, SCIP_Real, SCIPgetHugeValue(), SCIPinfinity(), SCIPquadprecSumQD, and TRUE.

Referenced by consdataGetActivityBounds(), consdataGetActivityResiduals(), consdataGetGlbActivityBounds(), and consdataGetGlbActivityResiduals().

getMaxActivity()

static void getMaxActivity ( SCIP *  scip, SCIP_CONSDATA *  consdata, int  posinf, int  neginf, int  poshuge, int  neghuge, SCIP_Real  delta, SCIP_Bool  global, SCIP_Bool  goodrelax, SCIP_Real *  maxactivity, SCIP_Bool *  istight, SCIP_Bool *  issettoinfinity  )

static

gets maximal activity for constraint and given values of counters for infinite and huge contributions and (if needed) delta to subtract from stored finite part of activity in case of a residual activity

Parameters

scip	SCIP data structure
consdata	linear constraint
posinf	number of coefficients contributing pos. infinite value
neginf	number of coefficients contributing neg. infinite value
poshuge	number of coefficients contributing huge pos. value
neghuge	number of coefficients contributing huge neg. value
delta	value to subtract from stored maxactivity (contribution of the variable set to zero when getting residual activity)
global	should the global or local maximal activity be returned?
goodrelax	should a good relaxation be computed or are relaxed acticities ignored, anyway?
maxactivity	pointer to store the maximal activity
istight	pointer to store whether activity bound is tight to variable bounds i.e. is the actual maxactivity (otherwise an upper bound is provided)
issettoinfinity	pointer to store whether maxactivity was set to infinity or calculated

Definition at line 2440 of file cons_linear.c.

References consdataRecomputeGlbMaxactivity(), consdataRecomputeMaxactivity(), FALSE, NULL, QUAD, QUAD_ASSIGN_Q, QUAD_TO_DBL, SCIP_Real, SCIPgetHugeValue(), SCIPinfinity(), SCIPquadprecSumQD, and TRUE.

Referenced by consdataGetActivityBounds(), consdataGetActivityResiduals(), consdataGetGlbActivityBounds(), and consdataGetGlbActivityResiduals().

consdataGetActivityBounds()

static void consdataGetActivityBounds ( SCIP *  scip, SCIP_CONSDATA *  consdata, SCIP_Bool  goodrelax, SCIP_Real *  minactivity, SCIP_Real *  maxactivity, SCIP_Bool *  ismintight, SCIP_Bool *  ismaxtight, SCIP_Bool *  isminsettoinfinity, SCIP_Bool *  ismaxsettoinfinity  )

static

gets activity bounds for constraint

Parameters

scip	SCIP data structure
consdata	linear constraint
goodrelax	if we have huge contributions, do we need a good relaxation or are relaxed activities ignored, anyway?
minactivity	pointer to store the minimal activity
maxactivity	pointer to store the maximal activity
ismintight	pointer to store whether the minactivity bound is tight i.e. is the actual minactivity (otherwise a lower bound is provided)
ismaxtight	pointer to store whether the maxactivity bound is tight i.e. is the actual maxactivity (otherwise an upper bound is provided)
isminsettoinfinity	pointer to store whether minactivity was set to infinity or calculated
ismaxsettoinfinity	pointer to store whether maxactivity was set to infinity or calculated

Definition at line 2533 of file cons_linear.c.

References consdataCalcActivities(), FALSE, getMaxActivity(), getMinActivity(), NULL, QUAD_TO_DBL, and SCIP_INVALID.

Referenced by consdataTightenCoefs(), presolStuffing(), propagateCons(), SCIP_DECL_CONSPRESOL(), and tightenBounds().

consdataGetReliableResidualActivity()

static void consdataGetReliableResidualActivity ( SCIP *  scip, SCIP_CONSDATA *  consdata, SCIP_VAR *  cancelvar, SCIP_Real *  resactivity, SCIP_Bool  isminresact, SCIP_Bool  useglobalbounds  )

static

calculates activity bounds for constraint after setting variable to zero

Parameters

scip	SCIP data structure
consdata	linear constraint
cancelvar	variable to calculate activity residual for
resactivity	pointer to store the residual activity
isminresact	should minimal or maximal residual activity be calculated?
useglobalbounds	should global or local bounds be used?

Definition at line 2580 of file cons_linear.c.

References NULL, REALABS, SCIP_Real, SCIPisHugeValue(), SCIPisInfinity(), SCIPisLE(), SCIPisZero(), SCIPvarGetLbGlobal(), SCIPvarGetLbLocal(), SCIPvarGetUbGlobal(), and SCIPvarGetUbLocal().

Referenced by addConflictBounds(), convertLongEquality(), dualPresolve(), fullDualPresolve(), and tightenVarBounds().

consdataGetActivityResiduals()

static void consdataGetActivityResiduals ( SCIP *  scip, SCIP_CONSDATA *  consdata, SCIP_VAR *  var, SCIP_Real  val, SCIP_Bool  goodrelax, SCIP_Real *  minresactivity, SCIP_Real *  maxresactivity, SCIP_Bool *  ismintight, SCIP_Bool *  ismaxtight, SCIP_Bool *  isminsettoinfinity, SCIP_Bool *  ismaxsettoinfinity  )

static

gets activity bounds for constraint after setting variable to zero

Parameters

scip	SCIP data structure
consdata	linear constraint
var	variable to calculate activity residual for
val	coefficient value of variable in linear constraint
goodrelax	if we have huge contributions, do we need a good relaxation or are relaxed acticities ignored, anyway?
minresactivity	pointer to store the minimal residual activity
maxresactivity	pointer to store the maximal residual activity
ismintight	pointer to store whether the residual minactivity bound is tight i.e. is the actual residual minactivity (otherwise a lower bound is provided)
ismaxtight	pointer to store whether the residual maxactivity bound is tight i.e. is the actual residual maxactivity (otherwise an upper bound is provided)
isminsettoinfinity	pointer to store whether minresactivity was set to infinity or calculated
ismaxsettoinfinity	pointer to store whether maxresactivity was set to infinity or calculated

Definition at line 2661 of file cons_linear.c.

References consdataCalcActivities(), FALSE, getMaxActivity(), getMinActivity(), NULL, QUAD_TO_DBL, SCIP_INVALID, SCIP_Real, SCIPisHugeValue(), SCIPisInfinity(), SCIPvarGetLbLocal(), and SCIPvarGetUbLocal().

Referenced by convertLongEquality(), dualPresolve(), and tightenVarBounds().

consdataGetGlbActivityBounds()

static void consdataGetGlbActivityBounds ( SCIP *  scip, SCIP_CONSDATA *  consdata, SCIP_Bool  goodrelax, SCIP_Real *  glbminactivity, SCIP_Real *  glbmaxactivity, SCIP_Bool *  ismintight, SCIP_Bool *  ismaxtight, SCIP_Bool *  isminsettoinfinity, SCIP_Bool *  ismaxsettoinfinity  )

static

gets global activity bounds for constraint

Parameters

scip	SCIP data structure
consdata	linear constraint
goodrelax	if we have huge contributions, do we need a good relaxation or are relaxed acticities ignored, anyway?
glbminactivity	pointer to store the minimal activity, or NULL, if not needed
glbmaxactivity	pointer to store the maximal activity, or NULL, if not needed
ismintight	pointer to store whether the minactivity bound is tight i.e. is the actual minactivity (otherwise a lower bound is provided)
ismaxtight	pointer to store whether the maxactivity bound is tight i.e. is the actual maxactivity (otherwise an upper bound is provided)
isminsettoinfinity	pointer to store whether minresactivity was set to infinity or calculated
ismaxsettoinfinity	pointer to store whether maxresactivity was set to infinity or calculated

Definition at line 2810 of file cons_linear.c.

References consdataCalcActivities(), getMaxActivity(), getMinActivity(), NULL, QUAD_TO_DBL, SCIP_INVALID, and TRUE.

Referenced by addConflictBounds(), and simplifyInequalities().

consdataGetGlbActivityResiduals()

static void consdataGetGlbActivityResiduals ( SCIP *  scip, SCIP_CONSDATA *  consdata, SCIP_VAR *  var, SCIP_Real  val, SCIP_Bool  goodrelax, SCIP_Real *  minresactivity, SCIP_Real *  maxresactivity, SCIP_Bool *  ismintight, SCIP_Bool *  ismaxtight, SCIP_Bool *  isminsettoinfinity, SCIP_Bool *  ismaxsettoinfinity  )

static

gets global activity bounds for constraint after setting variable to zero

Parameters

scip	SCIP data structure
consdata	linear constraint
var	variable to calculate activity residual for
val	coefficient value of variable in linear constraint
goodrelax	if we have huge contributions, do we need a good relaxation or are relaxed acticities ignored, anyway?
minresactivity	pointer to store the minimal residual activity, or NULL, if not needed
maxresactivity	pointer to store the maximal residual activity, or NULL, if not needed
ismintight	pointer to store whether the residual minactivity bound is tight i.e. is the actual residual minactivity (otherwise a lower bound is provided)
ismaxtight	pointer to store whether the residual maxactivity bound is tight i.e. is the actual residual maxactivity (otherwise an upper bound is provided)
isminsettoinfinity	pointer to store whether minresactivity was set to infinity or calculated
ismaxsettoinfinity	pointer to store whether maxresactivity was set to infinity or calculated

Definition at line 2870 of file cons_linear.c.

References consdataCalcActivities(), getMaxActivity(), getMinActivity(), NULL, QUAD_TO_DBL, SCIP_INVALID, SCIP_Real, SCIPisHugeValue(), SCIPisInfinity(), SCIPvarGetLbGlobal(), SCIPvarGetUbGlobal(), and TRUE.

Referenced by addConflictBounds(), and fullDualPresolve().

consdataGetActivity()

static SCIP_Real consdataGetActivity ( SCIP *  scip, SCIP_CONSDATA *  consdata, SCIP_SOL *  sol  )

static

calculates the activity of the linear constraint for given solution

Parameters

scip	SCIP data structure
consdata	linear constraint data
sol	solution to get activity for, NULL to current solution

Definition at line 3020 of file cons_linear.c.

References consdataComputePseudoActivity(), MAX, MIN, NULL, SCIP_Bool, SCIP_INVALID, SCIP_Real, SCIPdebugMsg, SCIPgetSolVal(), SCIPhasCurrentNodeLP(), SCIPinfinity(), SCIPisInfinity(), and SCIPisZero().

Referenced by checkCons(), consdataGetFeasibility(), SCIP_DECL_CONSCHECK(), and SCIPgetActivityLinear().

consdataGetFeasibility()

static SCIP_Real consdataGetFeasibility ( SCIP *  scip, SCIP_CONSDATA *  consdata, SCIP_SOL *  sol  )

static

calculates the feasibility of the linear constraint for given solution

Parameters

scip	SCIP data structure
consdata	linear constraint data
sol	solution to get feasibility for, NULL to current solution

Definition at line 3086 of file cons_linear.c.

References consdataGetActivity(), MIN, NULL, SCIP_INVALID, SCIP_Real, and SCIPinfinity().

Referenced by SCIPgetFeasibilityLinear().

consdataUpdateSignatures()

static void consdataUpdateSignatures ( SCIP_CONSDATA *  consdata, int  pos  )

static

updates bit signatures after adding a single coefficient

Parameters

consdata	linear constraint data
pos	position of coefficient to update signatures for

Definition at line 3107 of file cons_linear.c.

References NULL, SCIP_Real, SCIPhashSignature64, SCIPvarGetIndex(), SCIPvarGetLbGlobal(), and SCIPvarGetUbGlobal().

Referenced by addCoef(), and consdataCalcSignatures().

consdataCalcSignatures()

static void consdataCalcSignatures ( SCIP_CONSDATA *  consdata )

static

calculates the bit signatures of the given constraint data

Parameters

consdata

linear constraint data

Definition at line 3132 of file cons_linear.c.

References consdataUpdateSignatures(), NULL, and TRUE.

Referenced by preprocessConstraintPairs().

SCIP_DECL_SORTINDCOMP() [1/3]

static SCIP_DECL_SORTINDCOMP ( consdataCompVar  )

static

index comparison method of linear constraints: compares two indices of the variable set in the linear constraint

Definition at line 3152 of file cons_linear.c.

References NULL, SCIP_DEPRECATED_VARTYPE_IMPLINT, SCIPvarCompare(), SCIPvarGetType(), SCIPvarIsBinary(), and SCIPvarIsImpliedIntegral().

SCIP_DECL_SORTINDCOMP() [2/3]

static SCIP_DECL_SORTINDCOMP ( consdataCompVarProp  )

static

index comparison method of linear constraints: compares two indices of the variable set in the linear constraint

Definition at line 3191 of file cons_linear.c.

References EPSGT, NULL, REALABS, SCIP_DEPRECATED_VARTYPE_IMPLINT, SCIP_Real, SCIPvarGetLbGlobal(), SCIPvarGetProbindex(), SCIPvarGetType(), SCIPvarGetUbGlobal(), SCIPvarIsBinary(), SCIPvarIsImpliedIntegral(), and SCIPvarIsIntegral().

permSortConsdata()

static void permSortConsdata ( SCIP_CONSDATA *  consdata, int *  perm, int  nvars  )

static

permutes the constraint's variables according to a given permutation.

Parameters

consdata	the constraint data
perm	the target permutation
nvars	the number of variables

Definition at line 3261 of file cons_linear.c.

References NULL, and SCIP_Real.

Referenced by consdataSort(), and simplifyInequalities().

consdataSort()

static SCIP_RETCODE consdataSort ( SCIP *  scip, SCIP_CONSDATA *  consdata  )

static

sorts linear constraint's variables depending on the stage of the solving process:

• during PRESOLVING sorts variables by binary, integer, implied integral, and continuous variables, and the variables of the same type by non-decreasing variable index

• during SOLVING sorts variables of the remaining problem by binary, integer, implied integral, and continuous variables, and binary and integer variables by their global max activity delta (within each group), ties within a group are broken by problem index of the variable.

  This fastens the propagation time of the constraint handler.

Parameters

scip	SCIP data structure
consdata	linear constraint data

Definition at line 3337 of file cons_linear.c.

References FALSE, NULL, permSortConsdata(), SCIP_CALL, SCIP_OKAY, SCIP_STAGE_INITSOLVE, SCIPallocBufferArray, SCIPfreeBufferArray, SCIPgetStage(), SCIPsort(), SCIPvarIsBinary(), and TRUE.

Referenced by detectRedundantConstraints(), extractCliques(), mergeMultiples(), preprocessConstraintPairs(), and tightenBounds().

chgLhs()

static SCIP_RETCODE chgLhs ( SCIP *  scip, SCIP_CONS *  cons, SCIP_Real  lhs  )

static

sets left hand side of linear constraint

Parameters

scip	SCIP data structure
cons	linear constraint
lhs	new left hand side

Definition at line 3404 of file cons_linear.c.

References ABS, FALSE, NLOCKTYPES, NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPchgRowLhs(), SCIPconsGetData(), SCIPconsIsLockedType(), SCIPconsIsTransformed(), SCIPinfinity(), SCIPisEQ(), SCIPisGT(), SCIPisInfinity(), SCIPisPositive(), SCIPisZero(), SCIPlockVarCons(), SCIPmarkConsPropagate(), SCIPunlockVarCons(), and TRUE.

Referenced by applyFixings(), consdataTightenCoefs(), convertLongEquality(), detectRedundantConstraints(), preprocessConstraintPairs(), rangedRowSimplify(), SCIP_DECL_CONSPRESOL(), SCIPaddCoefLinear(), SCIPchgLhsLinear(), simplifyInequalities(), and tightenSides().

chgRhs()

static SCIP_RETCODE chgRhs ( SCIP *  scip, SCIP_CONS *  cons, SCIP_Real  rhs  )

static

sets right hand side of linear constraint

Parameters

scip	SCIP data structure
cons	linear constraint
rhs	new right hand side

Definition at line 3532 of file cons_linear.c.

References ABS, FALSE, NLOCKTYPES, NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPchgRowRhs(), SCIPconsGetData(), SCIPconsIsLockedType(), SCIPconsIsTransformed(), SCIPinfinity(), SCIPisEQ(), SCIPisInfinity(), SCIPisLT(), SCIPisPositive(), SCIPisZero(), SCIPlockVarCons(), SCIPmarkConsPropagate(), SCIPunlockVarCons(), and TRUE.

Referenced by applyFixings(), consdataTightenCoefs(), convertLongEquality(), detectRedundantConstraints(), preprocessConstraintPairs(), rangedRowSimplify(), SCIP_DECL_CONSPRESOL(), SCIPaddCoefLinear(), SCIPchgRhsLinear(), simplifyInequalities(), and tightenSides().

addCoef()

static SCIP_RETCODE addCoef ( SCIP *  scip, SCIP_CONS *  cons, SCIP_VAR *  var, SCIP_Real  val  )

static

adds coefficient in linear constraint

Parameters

scip	SCIP data structure
cons	linear constraint
var	variable of constraint entry
val	coefficient of constraint entry

Definition at line 3662 of file cons_linear.c.

References consCatchEvent(), consdataEnsureVarsSize(), consdataUpdateAddCoef(), consdataUpdateSignatures(), FALSE, lockRounding(), NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_STAGE_INITSOLVE, SCIPaddVarToRow(), SCIPcaptureVar(), SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetData(), SCIPconsIsChecked(), SCIPconsIsEnforced(), SCIPconsIsTransformed(), SCIPgetStage(), SCIPgetTransformedVar(), SCIPisZero(), SCIPmarkConsPropagate(), SCIPvarIsActive(), SCIPvarIsBinary(), SCIPvarIsIntegral(), SCIPvarIsRelaxationOnly(), SCIPvarIsTransformed(), and TRUE.

Referenced by applyFixings(), and SCIPaddCoefLinear().

delCoefPos()

static SCIP_RETCODE delCoefPos ( SCIP *  scip, SCIP_CONS *  cons, int  pos  )

static

deletes coefficient at given position from linear constraint data

Parameters

scip	SCIP data structure
cons	linear constraint
pos	position of coefficient to delete

Definition at line 3795 of file cons_linear.c.

References consdataInvalidateActivities(), consdataUpdateDelCoef(), consDropEvent(), FALSE, NULL, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPaddVarToRow(), SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetData(), SCIPconsIsTransformed(), SCIPisZero(), SCIPmarkConsPropagate(), SCIPreleaseVar(), SCIPvarIsBinary(), TRUE, and unlockRounding().

Referenced by applyFixings(), consdataTightenCoefs(), convertLongEquality(), mergeMultiples(), performVarDeletions(), scaleCons(), SCIPchgCoefLinear(), and simplifyInequalities().

chgCoefPos()

static SCIP_RETCODE chgCoefPos ( SCIP *  scip, SCIP_CONS *  cons, int  pos, SCIP_Real  newval  )

static

changes coefficient value at given position of linear constraint data

Parameters

scip	SCIP data structure
cons	linear constraint
pos	position of coefficient to delete
newval	new value of coefficient

Definition at line 3908 of file cons_linear.c.

References consdataUpdateAddCoef(), consdataUpdateChgCoef(), consdataUpdateDelCoef(), FALSE, lockRounding(), NLOCKTYPES, NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPconsGetData(), SCIPconsIsLockedType(), SCIPconsIsTransformed(), SCIPisNegative(), SCIPisPositive(), SCIPisZero(), SCIPmarkConsPropagate(), SCIPvarIsTransformed(), TRUE, and unlockRounding().

Referenced by consdataTightenCoefs(), mergeMultiples(), rangedRowSimplify(), SCIPchgCoefLinear(), and simplifyInequalities().

scaleCons()

static SCIP_RETCODE scaleCons ( SCIP *  scip, SCIP_CONS *  cons, SCIP_Real  scalar  )

static

scales a linear constraint with a constant scalar

Parameters

scip	SCIP data structure
cons	linear constraint to scale
scalar	value to scale constraint with

Definition at line 3998 of file cons_linear.c.

References consdataInvalidateActivities(), delCoefPos(), FALSE, NULL, REALABS, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPconsGetData(), SCIPconsGetName(), SCIPfeasCeil(), SCIPfeasFloor(), SCIPisInfinity(), SCIPisScalingIntegral(), SCIPisZero(), SCIPvarGetName(), and SCIPwarningMessage().

Referenced by normalizeCons().

performVarDeletions()

static SCIP_RETCODE performVarDeletions ( SCIP *  scip, SCIP_CONSHDLR *  conshdlr, SCIP_CONS **  conss, int  nconss  )

static

perform deletion of variables in all constraints of the constraint handler

Parameters

scip	SCIP data structure
conshdlr	constraint handler
conss	array of constraints
nconss	number of constraints

Definition at line 4091 of file cons_linear.c.

References CONSHDLR_NAME, delCoefPos(), FALSE, NULL, SCIP_CALL, SCIP_OKAY, SCIPconsGetData(), SCIPconshdlrGetName(), and SCIPvarIsDeleted().

Referenced by SCIP_DECL_CONSDELVARS().

normalizeCons()

static SCIP_RETCODE normalizeCons ( SCIP *  scip, SCIP_CONS *  cons, SCIP_Bool *  infeasible  )

static

normalizes a linear constraint with the following rules:

• if all coefficients have them same absolute value, change them to (-)1.0
• multiplication with +1 or -1: Apply the following rules in the given order, until the sign of the factor is determined. Later rules only apply, if the current rule doesn't determine the sign):
  1. the right hand side must not be negative
  2. the right hand side must not be infinite
  3. the absolute value of the right hand side must be greater than that of the left hand side
  4. the number of positive coefficients must not be smaller than the number of negative coefficients
  5. multiply with +1
• rationals to integrals Try to identify a rational representation of the fractional coefficients, and multiply all coefficients by the smallest common multiple of all denominators to get integral coefficients. Forbid large denominators due to numerical stability.
• division by greatest common divisor If all coefficients are integral, divide them by the greatest common divisor.

Parameters

scip	SCIP data structure
cons	linear constraint to normalize
infeasible	pointer to store whether infeasibility was detected

Definition at line 4150 of file cons_linear.c.

References consdataCalcMaxAbsval(), consdataCalcMinAbsval(), consdataCheckNonbinvar(), consdataGetMaxAbsval(), consdataGetMinAbsval(), scip::denominator(), FALSE, MAX, MAXSCALEDCOEF, MAXSCALEDCOEFINTEGER, MIN, NULL, scip::numerator(), REALABS, scaleCons(), SCIP_Bool, SCIP_CALL, SCIP_INVALID, SCIP_Longint, SCIP_LONGINT_FORMAT, SCIP_OKAY, SCIP_Real, SCIPcalcGreComDiv(), SCIPcalcSmaComMul(), SCIPconsGetData(), SCIPconsIsModifiable(), SCIPdebugMsg, SCIPdebugPrintCons, SCIPepsilon(), SCIPfeastol(), SCIPisEQ(), SCIPisFeasIntegral(), SCIPisFeasZero(), SCIPisGT(), SCIPisInfinity(), SCIPisIntegral(), SCIPisLE(), SCIPisLT(), SCIPisNegative(), SCIPisPositive(), SCIPisZero(), SCIPrealToRational(), and TRUE.

Referenced by aggregateConstraints(), aggregateVariables(), SCIP_DECL_CONSPRESOL(), SCIPupgradeConsLinear(), and simplifyInequalities().

mergeMultiples()

static SCIP_RETCODE mergeMultiples ( SCIP *  scip, SCIP_CONS *  cons  )

static

replaces multiple occurrences of a variable by a single non-zero coefficient

Parameters

scip	SCIP data structure
cons	linear constraint

Definition at line 4470 of file cons_linear.c.

References chgCoefPos(), consdataSort(), delCoefPos(), NULL, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPconsGetData(), SCIPisZero(), and TRUE.

Referenced by applyFixings(), and SCIPclassifyConstraintTypesLinear().

applyFixings()

static SCIP_RETCODE applyFixings ( SCIP *  scip, SCIP_CONS *  cons, SCIP_Bool *  infeasible  )

static

replaces all fixed and aggregated variables by their non-fixed counterparts

Parameters

scip	SCIP data structure
cons	linear constraint
infeasible	pointer to store if infeasibility is detected; or NULL if this information is not needed; in this case, we apply all fixings instead of stopping after the first infeasible one

Definition at line 4533 of file cons_linear.c.

References ABS, addCoef(), chgLhs(), chgRhs(), consCatchAllEvents(), delCoefPos(), FALSE, mergeMultiples(), NULL, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_Real, SCIP_VARSTATUS_AGGREGATED, SCIP_VARSTATUS_COLUMN, SCIP_VARSTATUS_FIXED, SCIP_VARSTATUS_LOOSE, SCIP_VARSTATUS_MULTAGGR, SCIP_VARSTATUS_NEGATED, SCIP_VARSTATUS_ORIGINAL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetData(), SCIPconsIsModifiable(), SCIPdebugMsg, SCIPdebugPrintCons, SCIPerrorMessage, SCIPflattenVarAggregationGraph(), SCIPgetProbvarSum(), SCIPinfinity(), SCIPisEQ(), SCIPisFeasGT(), SCIPisFeasLT(), SCIPisGE(), SCIPisInfinity(), SCIProwIsInLP(), SCIProwIsModifiable(), SCIPvarGetMultaggrConstant(), SCIPvarGetMultaggrNVars(), SCIPvarGetMultaggrScalars(), SCIPvarGetMultaggrVars(), SCIPvarGetStatus(), SCIPvarIsActive(), SCIPvarIsTransformed(), and TRUE.

Referenced by addRelaxation(), aggregateVariables(), fixVariables(), SCIP_DECL_CONSEXITPRE(), SCIP_DECL_CONSPRESOL(), SCIPcleanupConssLinear(), and tightenBounds().

addConflictBounds()

static SCIP_RETCODE addConflictBounds ( SCIP *  scip, SCIP_CONS *  cons, SCIP_VAR *  infervar, SCIP_BDCHGIDX *  bdchgidx, int  inferpos, SCIP_Bool  reasonisrhs  )

static

for each variable in the linear constraint, except the inferred variable, adds one bound to the conflict analysis' candidate store (bound depends on sign of coefficient and whether the left or right hand side was the reason for the inference variable's bound change); the conflict analysis can be initialized with the linear constraint being the conflict detecting constraint by using NULL as inferred variable

Parameters

scip	SCIP data structure
cons	constraint that inferred the bound change
infervar	variable that was deduced, or NULL
bdchgidx	bound change index (time stamp of bound change), or NULL for current time
inferpos	position of the inferred variable in the vars array
reasonisrhs	is the right hand side responsible for the bound change?

Definition at line 4798 of file cons_linear.c.

References consdataGetGlbActivityBounds(), consdataGetGlbActivityResiduals(), consdataGetReliableResidualActivity(), FALSE, NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPconsGetData(), SCIPgetVarLbAtIndex(), SCIPgetVarUbAtIndex(), SCIPinfinity(), SCIPisFeasNegative(), SCIPisFeasPositive(), SCIPisInfinity(), SCIPisUpdateUnreliable(), SCIPisZero(), SCIPvarGetLbGlobal(), SCIPvarGetUbGlobal(), SCIPvarIsIntegral(), and TRUE.

Referenced by analyzeConflict(), and resolvePropagation().

addConflictFixedVars()

static SCIP_RETCODE addConflictFixedVars ( SCIP *  scip, SCIP_CONS *  cons, SCIP_VAR *  infervar, SCIP_BDCHGIDX *  bdchgidx, int  inferpos  )

static

for each variable in the linear ranged row constraint, except the inferred variable, adds the bounds of all fixed variables to the conflict analysis' candidate store; the conflict analysis can be initialized with the linear constraint being the conflict detecting constraint by using NULL as inferred variable

Parameters

scip	SCIP data structure
cons	constraint that inferred the bound change
infervar	variable that was deduced, or NULL
bdchgidx	bound change index (time stamp of bound change), or NULL for current time
inferpos	position of the inferred variable in the vars array, or -1

Definition at line 4980 of file cons_linear.c.

References FALSE, NULL, SCIP_CALL, SCIP_OKAY, SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPconsGetData(), SCIPgetVarLbAtIndex(), SCIPgetVarUbAtIndex(), SCIPisEQ(), SCIPvarGetLbGlobal(), and SCIPvarGetUbGlobal().

Referenced by analyzeConflictRangedRow(), and resolvePropagation().

addConflictReasonVars()

static SCIP_RETCODE addConflictReasonVars ( SCIP *  scip, SCIP_VAR **  vars, int  nvars, SCIP_VAR *  var, SCIP_Real  bound  )

static

add reasoning variables to conflict candidate queue which led to the conflict

Parameters

scip	SCIP data structure
vars	variables reasoning the infeasibility
nvars	number of variables reasoning the infeasibility
var	variable which was tried to fix/tighten, or NULL
bound	bound of variable which was tried to apply, or SCIP_INVALID

Definition at line 5045 of file cons_linear.c.

References bound, NULL, SCIP_CALL, SCIP_OKAY, SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPisEQ(), SCIPvarGetLbGlobal(), SCIPvarGetLbLocal(), SCIPvarGetUbGlobal(), and SCIPvarGetUbLocal().

Referenced by analyzeConflictRangedRow().

resolvePropagation()

static SCIP_RETCODE resolvePropagation ( SCIP *  scip, SCIP_CONS *  cons, SCIP_VAR *  infervar, INFERINFO  inferinfo, SCIP_BOUNDTYPE  boundtype, SCIP_BDCHGIDX *  bdchgidx, SCIP_RESULT *  result  )

static

resolves a propagation on the given variable by supplying the variables needed for applying the corresponding propagation rule (see propagateCons()): (1) activity residuals of all other variables tighten bounds of single variable

Parameters

scip	SCIP data structure
cons	constraint that inferred the bound change
infervar	variable that was deduced
inferinfo	inference information
boundtype	the type of the changed bound (lower or upper bound)
bdchgidx	bound change index (time stamp of bound change), or NULL for current time
result	pointer to store the result of the propagation conflict resolving call

Definition at line 5096 of file cons_linear.c.

References addConflictBounds(), addConflictFixedVars(), FALSE, inferInfoGetPos(), inferInfoGetProprule(), NULL, PROPRULE_1_LHS, PROPRULE_1_RANGEDROW, PROPRULE_1_RHS, PROPRULE_INVALID, SCIP_BOUNDTYPE_LOWER, SCIP_BOUNDTYPE_UPPER, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_Real, SCIP_SUCCESS, SCIPconsGetData(), SCIPconsGetName(), SCIPerrorMessage, SCIPinfoMessage(), SCIPisInfinity(), SCIPisZero(), SCIPprintCons(), SCIPvarGetName(), and TRUE.

Referenced by SCIP_DECL_CONSRESPROP().

analyzeConflict()

static SCIP_RETCODE analyzeConflict ( SCIP *  scip, SCIP_CONS *  cons, SCIP_Bool  reasonisrhs  )

static

analyzes conflicting bounds on given constraint, and adds conflict constraint to problem

Parameters

scip	SCIP data structure
cons	conflict detecting constraint
reasonisrhs	is the right hand side responsible for the conflict?

Definition at line 5189 of file cons_linear.c.

References addConflictBounds(), FALSE, NULL, SCIP_CALL, SCIP_CONFTYPE_PROPAGATION, SCIP_OKAY, SCIP_STAGE_SOLVING, SCIPanalyzeConflictCons(), SCIPgetStage(), SCIPinitConflictAnalysis(), SCIPinProbing(), and SCIPisConflictAnalysisApplicable().

Referenced by propagateCons(), tightenVarBounds(), tightenVarLb(), and tightenVarUb().

canTightenBounds()

static SCIP_Bool canTightenBounds ( SCIP_CONS *  cons )

static

check if there is any hope of tightening some bounds

Parameters

cons	linear constraint

Definition at line 5213 of file cons_linear.c.

References FALSE, NULL, SCIPconsGetData(), and TRUE.

Referenced by tightenBounds().

tightenVarUb()

static SCIP_RETCODE tightenVarUb ( SCIP *  scip, SCIP_CONS *  cons, int  pos, PROPRULE  proprule, SCIP_Real  newub, SCIP_Real  oldub, SCIP_Bool *  cutoff, int *  nchgbds, SCIP_Bool  force  )

static

tighten upper bound

Parameters

scip	SCIP data structure
cons	linear constraint
pos	variable position
proprule	propagation rule that deduced the value
newub	new upper bound
oldub	old upper bound
cutoff	pointer to store whether the node can be cut off
nchgbds	pointer to count the total number of tightened bounds
force	should a possible bound change be forced even if below bound strengthening tolerance

Definition at line 5241 of file cons_linear.c.

References analyzeConflict(), FALSE, getInferInt(), NULL, QUAD_TO_DBL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPadjustedVarUb(), SCIPconsGetData(), SCIPconsGetName(), SCIPdebugMsg, SCIPinferVarUbCons(), SCIPisFeasLE(), SCIPisInfinity(), SCIPisUbBetter(), SCIPvarGetImplType(), SCIPvarGetLbLocal(), SCIPvarGetName(), SCIPvarGetType(), SCIPvarGetUbLocal(), and TRUE.

Referenced by tightenVarBoundsEasy().

tightenVarLb()

static SCIP_RETCODE tightenVarLb ( SCIP *  scip, SCIP_CONS *  cons, int  pos, PROPRULE  proprule, SCIP_Real  newlb, SCIP_Real  oldlb, SCIP_Bool *  cutoff, int *  nchgbds, SCIP_Bool  force  )

static

tighten lower bound

Parameters

scip	SCIP data structure
cons	linear constraint
pos	variable position
proprule	propagation rule that deduced the value
newlb	new lower bound
oldlb	old lower bound
cutoff	pointer to store whether the node can be cut off
nchgbds	pointer to count the total number of tightened bounds
force	should a possible bound change be forced even if below bound strengthening tolerance

Definition at line 5310 of file cons_linear.c.

References analyzeConflict(), FALSE, getInferInt(), NULL, QUAD_TO_DBL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPadjustedVarLb(), SCIPconsGetData(), SCIPconsGetName(), SCIPdebugMsg, SCIPinferVarLbCons(), SCIPisFeasGE(), SCIPisInfinity(), SCIPisLbBetter(), SCIPvarGetImplType(), SCIPvarGetLbLocal(), SCIPvarGetName(), SCIPvarGetType(), SCIPvarGetUbLocal(), and TRUE.

Referenced by tightenVarBoundsEasy().

tightenVarBoundsEasy()

static SCIP_RETCODE tightenVarBoundsEasy ( SCIP *  scip, SCIP_CONS *  cons, int  pos, SCIP_Bool *  cutoff, int *  nchgbds, SCIP_Bool  force  )

static

tightens bounds of a single variable due to activity bounds (easy case)

Parameters

scip	SCIP data structure
cons	linear constraint
pos	position of the variable in the vars array
cutoff	pointer to store whether the node can be cut off
nchgbds	pointer to count the total number of tightened bounds
force	should a possible bound change be forced even if below bound strengthening tolerance

Definition at line 5379 of file cons_linear.c.

References consdataCalcActivities(), consdataRecomputeMaxactivity(), consdataRecomputeMinactivity(), FALSE, NULL, PROPRULE_1_LHS, PROPRULE_1_RHS, QUAD_TO_DBL, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIP_VARSTATUS_MULTAGGR, SCIPconsGetData(), SCIPconsGetName(), SCIPconsIsModifiable(), SCIPdebugMsg, SCIPisFeasLT(), SCIPisGT(), SCIPisInfinity(), SCIPisLE(), SCIPisNegative(), SCIPisPositive(), SCIPisSumGT(), SCIPisZero(), SCIPvarGetLbLocal(), SCIPvarGetName(), SCIPvarGetStatus(), SCIPvarGetUbLocal(), tightenVarLb(), tightenVarUb(), and TRUE.

Referenced by tightenBounds().

analyzeConflictRangedRow()

static SCIP_RETCODE analyzeConflictRangedRow ( SCIP *  scip, SCIP_CONS *  cons, SCIP_VAR **  vars, int  nvars, SCIP_VAR *  var, SCIP_Real  bound  )

static

analyzes conflicting bounds on given ranged row constraint, and adds conflict constraint to problem

Parameters

scip	SCIP data structure
cons	conflict detecting constraint
vars	variables reasoning the infeasibility
nvars	number of variables reasoning the infeasibility
var	variable which was tried to fix/tighten, or NULL
bound	bound of variable which was tried to apply, or SCIP_INVALID

Definition at line 5656 of file cons_linear.c.

References addConflictFixedVars(), addConflictReasonVars(), bound, FALSE, NULL, SCIP_CALL, SCIP_CONFTYPE_PROPAGATION, SCIP_OKAY, SCIP_STAGE_SOLVING, SCIPanalyzeConflictCons(), SCIPconsGetData(), SCIPgetStage(), SCIPinitConflictAnalysis(), SCIPinProbing(), SCIPisConflictAnalysisApplicable(), and SCIPisInfinity().

Referenced by rangedRowPropagation().

rangedRowPropagation()

static SCIP_RETCODE rangedRowPropagation ( SCIP *  scip, SCIP_CONS *  cons, SCIP_Bool *  cutoff, int *  nfixedvars, int *  nchgbds, int *  naddconss  )

static

propagate ranged rows

Check ranged rows for possible solutions, possibly detect infeasibility, fix variables due to having only one possible solution, tighten bounds if having only two possible solutions or add constraints which propagate a subset of variables better.

Example: c1: 12 x1 + 9 x2 - x3 = 0 with x1, x2 free and 1 <= x3 <= 2

x3 needs to be a multiple of 3, so the instance is infeasible.

Example: c1: 12 x1 + 9 x2 - x3 = 1 with x1, x2 free and 1 <= x3 <= 2

The only possible value for x3 is 2, so the variable will be fixed.

Parameters

scip	SCIP data structure
cons	linear constraint
cutoff	pointer to store TRUE, if a cutoff was found
nfixedvars	pointer to count number of fixed variables
nchgbds	pointer to count the number of bound changes
naddconss	pointer to count number of added constraints

Definition at line 5714 of file cons_linear.c.

References analyzeConflictRangedRow(), bound, FALSE, getInferInt(), NULL, PROPRULE_1_RANGEDROW, REALABS, SCIP_Bool, SCIP_CALL, SCIP_INVALID, SCIP_Longint, SCIP_MAXSTRLEN, SCIP_OKAY, SCIP_Real, SCIP_REAL_MAX, SCIPaddConsLocal(), SCIPallocBufferArray, SCIPcalcGreComDiv(), SCIPceil(), SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconshdlrGetData(), SCIPconsIsModifiable(), SCIPcreateConsLinear(), SCIPdebugMsg, SCIPdebugPrintCons, SCIPfeastol(), SCIPfloor(), SCIPfreeBufferArray, SCIPgetDepth(), SCIPinferVarFixCons(), SCIPinferVarLbCons(), SCIPinferVarUbCons(), SCIPinfinity(), SCIPinProbing(), SCIPinRepropagation(), SCIPisEQ(), SCIPisGE(), SCIPisGT(), SCIPisHugeValue(), SCIPisInfinity(), SCIPisIntegral(), SCIPisLE(), SCIPisLT(), SCIPisZero(), SCIPreleaseCons(), SCIPsnprintf(), SCIPvarGetLbLocal(), SCIPvarGetName(), SCIPvarGetUbLocal(), SCIPvarIsBinary(), SCIPvarIsIntegral(), TRUE, and w.

Referenced by propagateCons(), and SCIP_DECL_CONSPRESOL().

tightenVarBounds()

static SCIP_RETCODE tightenVarBounds ( SCIP *  scip, SCIP_CONS *  cons, int  pos, SCIP_Bool *  cutoff, int *  nchgbds, SCIP_Bool  force  )

static

tightens bounds of a single variable due to activity bounds

Parameters

scip	SCIP data structure
cons	linear constraint
pos	position of the variable in the vars array
cutoff	pointer to store whether the node can be cut off
nchgbds	pointer to count the total number of tightened bounds
force	should a possible bound change be forced even if below bound strengthening tolerance

Definition at line 6697 of file cons_linear.c.

References ABS, analyzeConflict(), consdataGetActivityResiduals(), consdataGetReliableResidualActivity(), FALSE, getInferInt(), NULL, PROPRULE_1_LHS, PROPRULE_1_RHS, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIP_VARSTATUS_MULTAGGR, SCIPconsGetData(), SCIPconsGetName(), SCIPconsIsModifiable(), SCIPdebugMsg, SCIPinferVarLbCons(), SCIPinferVarUbCons(), SCIPisEQ(), SCIPisFeasGE(), SCIPisFeasGT(), SCIPisFeasLE(), SCIPisFeasLT(), SCIPisGT(), SCIPisInfinity(), SCIPisLbBetter(), SCIPisLE(), SCIPisLT(), SCIPisUbBetter(), SCIPisUpdateUnreliable(), SCIPisZero(), SCIPvarGetLbLocal(), SCIPvarGetName(), SCIPvarGetStatus(), SCIPvarGetUbLocal(), SCIPvarIsIntegral(), and TRUE.

Referenced by tightenBounds().

tightenBounds()

static SCIP_RETCODE tightenBounds ( SCIP *  scip, SCIP_CONS *  cons, SCIP_Real  maxeasyactivitydelta, SCIP_Bool  sortvars, SCIP_Bool *  cutoff, int *  nchgbds  )

static

tightens bounds of variables in constraint due to activity bounds

Parameters

scip	SCIP data structure
cons	linear constraint
maxeasyactivitydelta	maximum activity delta to run easy propagation on linear constraint
sortvars	should variables be used in sorted order?
cutoff	pointer to store whether the node can be cut off
nchgbds	pointer to count the total number of tightened bounds

Definition at line 6977 of file cons_linear.c.

References applyFixings(), canTightenBounds(), checkMaxActivityDelta, consdataGetActivityBounds(), consdataRecomputeMaxActivityDelta(), consdataSort(), FALSE, MAXTIGHTENROUNDS, MIN, NULL, SCIP_Bool, SCIP_CALL, SCIP_INVALID, SCIP_OKAY, SCIP_Real, SCIP_STAGE_INITSOLVE, SCIPconsGetData(), SCIPconsGetName(), SCIPconsIsModifiable(), SCIPdebugMessage, SCIPgetDepth(), SCIPgetStage(), SCIPinfinity(), SCIPisEQ(), SCIPisFeasEQ(), SCIPisFeasNegative(), SCIPisFeasZero(), SCIPisInfinity(), SCIPisLE(), SCIPisLT(), SCIPvarGetLbLocal(), SCIPvarGetUbLocal(), tightenVarBounds(), and tightenVarBoundsEasy().

Referenced by extractCliques(), propagateCons(), and SCIP_DECL_CONSPRESOL().

checkCons()

static SCIP_RETCODE checkCons ( SCIP *  scip, SCIP_CONS *  cons, SCIP_SOL *  sol, SCIP_Bool  checklprows, SCIP_Bool  checkrelmaxabs, SCIP_Bool *  violated  )

static

checks linear constraint for feasibility of given solution or current solution

Parameters

scip	SCIP data structure
cons	linear constraint
sol	solution to be checked, or NULL for current solution
checklprows	Do constraints represented by rows in the current LP have to be checked?
checkrelmaxabs	Should the violation for a constraint with side 0.0 be checked relative to 1.0 (FALSE) or to the maximum absolute value in the activity (TRUE)?
violated	pointer to store whether the constraint is violated

Definition at line 7155 of file cons_linear.c.

References consdataComputePseudoActivity(), consdataGetActivity(), consPrintConsSol(), FALSE, MAX, NULL, REALABS, SCIP_CALL, SCIP_INVALID, SCIP_OKAY, SCIP_Real, SCIPconsGetData(), SCIPconsGetName(), SCIPdebug, SCIPdebugMsg, SCIPdebugPrintCons, SCIPfeastol(), SCIPgetRowSolActivity(), SCIPgetSolVal(), SCIPhasCurrentNodeLP(), SCIPincConsAge(), SCIPisFeasGT(), SCIPisFeasLT(), SCIPisGT(), SCIPisInfinity(), SCIPisZero(), SCIPrelDiff(), SCIPresetConsAge(), SCIProwIsInLP(), SCIPupdateSolLPConsViolation(), and TRUE.

Referenced by enforceConstraint(), SCIP_DECL_CONSCHECK(), SCIP_DECL_CONSENFOPS(), and separateCons().

createRow()

static SCIP_RETCODE createRow ( SCIP *  scip, SCIP_CONS *  cons  )

static

creates an LP row in a linear constraint data

Parameters

scip	SCIP data structure
cons	linear constraint

Definition at line 7415 of file cons_linear.c.

References NULL, SCIP_CALL, SCIP_OKAY, SCIPaddVarsToRow(), SCIPconsGetData(), SCIPconsGetName(), SCIPconsIsLocal(), SCIPconsIsModifiable(), SCIPconsIsRemovable(), and SCIPcreateEmptyRowCons().

Referenced by addRelaxation().

addRelaxation()

static SCIP_RETCODE addRelaxation ( SCIP *  scip, SCIP_CONS *  cons, SCIP_Bool *  cutoff  )

static

adds linear constraint as cut to the LP

Parameters

scip	SCIP data structure
cons	linear constraint
cutoff	pointer to store whether a cutoff was found

Definition at line 7439 of file cons_linear.c.

References applyFixings(), createRow(), FALSE, NULL, SCIP_CALL, SCIP_OKAY, SCIPaddRow(), SCIPconsGetData(), SCIPconsGetName(), SCIPconsIsModifiable(), SCIPdebug, SCIPdebugMsg, SCIPgetIntParam(), SCIPisInfinity(), SCIPprintRow(), and SCIProwIsInLP().

Referenced by enforceConstraint(), SCIP_DECL_CONSINITLP(), and separateCons().

addNlrow()

static SCIP_RETCODE addNlrow ( SCIP *  scip, SCIP_CONS *  cons  )

static

adds linear constraint as row to the NLP, if not added yet

Parameters

scip	SCIP data structure
cons	linear constraint

Definition at line 7502 of file cons_linear.c.

References NULL, SCIP_CALL, SCIP_EXPRCURV_LINEAR, SCIP_OKAY, SCIPaddNlRow(), SCIPconsGetData(), SCIPconsGetName(), SCIPconsIsActive(), SCIPconsIsChecked(), SCIPconsIsLocal(), SCIPcreateNlRow(), SCIPisNLPConstructed(), and SCIPnlrowIsInNLP().

Referenced by SCIP_DECL_CONSACTIVE(), and SCIP_DECL_CONSINITSOL().

separateCons()

static SCIP_RETCODE separateCons ( SCIP *  scip, SCIP_CONS *  cons, SCIP_CONSHDLRDATA *  conshdlrdata, SCIP_SOL *  sol, SCIP_Bool  separatecards, SCIP_Bool  separateall, int *  ncuts, SCIP_Bool *  cutoff  )

static

separates linear constraint: adds linear constraint as cut, if violated by given solution

Parameters

scip	SCIP data structure
cons	linear constraint
conshdlrdata	constraint handler data
sol	primal CIP solution, NULL for current LP solution
separatecards	should knapsack cardinality cuts be generated?
separateall	should all constraints be subject to cardinality cut generation instead of only the ones with non-zero dual value?
ncuts	pointer to add up the number of found cuts
cutoff	pointer to store whether a cutoff was found

Definition at line 7538 of file cons_linear.c.

References addRelaxation(), checkCons(), FALSE, NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPconsGetData(), SCIPconsIsModifiable(), SCIPisFeasNegative(), SCIPisFeasPositive(), SCIPisInfinity(), SCIPresetConsAge(), SCIProwGetDualsol(), SCIProwIsInLP(), and SCIPseparateRelaxedKnapsack().

Referenced by SCIP_DECL_CONSSEPALP(), and SCIP_DECL_CONSSEPASOL().

propagateCons()

static SCIP_RETCODE propagateCons ( SCIP *  scip, SCIP_CONS *  cons, SCIP_Bool  tightenbounds, SCIP_Bool  rangedrowpropagation, SCIP_Real  maxeasyactivitydelta, SCIP_Bool  sortvars, SCIP_Bool *  cutoff, int *  nchgbds  )

static

propagation method for linear constraints

Parameters

scip	SCIP data structure
cons	linear constraint
tightenbounds	should the variable's bounds be tightened?
rangedrowpropagation	should ranged row propagation be performed?
maxeasyactivitydelta	maximum activity delta to run easy propagation on linear constraint
sortvars	should variable sorting for faster propagation be used?
cutoff	pointer to store whether the node can be cut off
nchgbds	pointer to count the total number of tightened bounds

Definition at line 7628 of file cons_linear.c.

References analyzeConflict(), consCatchAllEvents(), consdataGetActivityBounds(), FALSE, NULL, rangedRowPropagation(), SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconshdlrGetData(), SCIPconsIsModifiable(), SCIPdebug, SCIPdebugMsg, SCIPdelCons(), SCIPdelConsLocal(), SCIPincConsAge(), SCIPinRepropagation(), SCIPisFeasGT(), SCIPisFeasLT(), SCIPisGE(), SCIPisLE(), SCIPresetConsAge(), tightenBounds(), and TRUE.

Referenced by SCIP_DECL_CONSPROP().

fixVariables()

static SCIP_RETCODE fixVariables ( SCIP *  scip, SCIP_CONS *  cons, SCIP_Bool *  cutoff, int *  nfixedvars  )

static

converts all variables with fixed domain into FIXED variables

Parameters

scip	SCIP data structure
cons	linear constraint
cutoff	pointer to store TRUE, if a cutoff was found
nfixedvars	pointer to count the total number of fixed variables

Definition at line 7776 of file cons_linear.c.

References applyFixings(), MAXDNOM, NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIP_VARSTATUS_FIXED, SCIPconsGetData(), SCIPdebugMsg, SCIPfixVar(), SCIPisEQ(), SCIPselectSimpleValue(), SCIPvarGetLbGlobal(), SCIPvarGetName(), SCIPvarGetStatus(), SCIPvarGetUbGlobal(), and TRUE.

Referenced by extractCliques(), and SCIP_DECL_CONSPRESOL().

extractCliques()

static SCIP_RETCODE extractCliques ( SCIP *  scip, SCIP_CONS *  cons, SCIP_Real  maxeasyactivitydelta, SCIP_Bool  sortvars, int *  nfixedvars, int *  nchgbds, SCIP_Bool *  cutoff  )

static

extracts cliques of the constraint and adds them to SCIP

The following clique extraction mechanism are implemeneted

1. collect binary variables and sort them in non increasing order, then

   a) if the constraint has a finite right hand side and the negative infinity counters for the minactivity are zero then add the variables as a clique for which all successive pairs of coefficients fullfill the following condition

   minactivity + vals[i] + vals[i+1] > rhs
   

   and also add the binary to binary implication also for non-successive variables for which the same argument holds

   minactivity + vals[i] + vals[j] > rhs
   

   e.g. 5.3 x1 + 3.6 x2 + 3.3 x3 + 2.1 x4 <= 5.5 (all x are binary) would lead to the clique (x1, x2, x3) and the binary to binary implications x1 = 1 => x4 = 0 and x2 = 1 => x4 = 0

   b) if the constraint has a finite left hand side and the positive infinity counters for the maxactivity are zero then add the variables as a clique for which all successive pairs of coefficients fullfill the follwoing condition

   maxactivity + vals[i] + vals[i-1] < lhs
   

   and also add the binary to binary implication also for non-successive variables for which the same argument holds

   maxactivity + vals[i] + vals[j] < lhs
   

   e.g. you could multiply the above example by -1

   c) the constraint has a finite right hand side and a finite minactivity then add the variables as a negated clique(clique on the negated variables) for which all successive pairs of coefficients fullfill the following condition

   minactivity - vals[i] - vals[i-1] > rhs
   

   and also add the binary to binary implication also for non-successive variables for which the same argument holds

   minactivity - vals[i] - vals[j] > rhs
   

   e.g. -4 x1 -3 x2 - 2 x3 + 2 x4 <= -4 would lead to the (negated) clique (~x1, ~x2) and the binary to binary implication x1 = 0 => x3 = 1

   d) the constraint has a finite left hand side and a finite maxactivity then add the variables as a negated clique(clique on the negated variables) for which all successive pairs of coefficients fullfill the following condition

   maxactivity - vals[i] - vals[i+1] < lhs
   

   and also add the binary to binary implication also for non-successive variables for which the same argument holds

   maxactivity - vals[i] - vals[j] < lhs
   

   e.g. you could multiply the above example by -1

2. if the linear constraint represents a set-packing or set-partitioning constraint, the whole constraint is added as clique, (this part is done at the end of the method)

Parameters

scip	SCIP data structure
cons	linear constraint
maxeasyactivitydelta	maximum activity delta to run easy propagation on linear constraint
sortvars	should variables be used in sorted order?
nfixedvars	pointer to count number of fixed variables
nchgbds	pointer to count the total number of tightened bounds
cutoff	pointer to store TRUE, if a cutoff was found

Definition at line 7911 of file cons_linear.c.

References BMSclearMemoryArray, consdataCalcActivities(), consdataRecomputeGlbMaxactivity(), consdataRecomputeGlbMinactivity(), consdataSort(), FALSE, fixVariables(), MAX_CLIQUE_NONZEROS_PER_CONS, NULL, QUAD_TO_DBL, REALABS, SCIP_Bool, SCIP_BOUNDTYPE_LOWER, SCIP_BOUNDTYPE_UPPER, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIP_VARTYPE_BINARY, SCIPaddClique(), SCIPaddVarImplication(), SCIPallocBufferArray, SCIPconsGetData(), SCIPconsGetName(), SCIPconsIsDeleted(), SCIPdebugMsg, SCIPduplicateBufferArray, SCIPfreeBufferArray, SCIPisEQ(), SCIPisFeasGE(), SCIPisFeasGT(), SCIPisFeasLE(), SCIPisFeasLT(), SCIPisInfinity(), SCIPisPositive(), SCIPisZero(), SCIPsortDownRealPtr(), SCIPvarGetLbGlobal(), SCIPvarGetType(), SCIPvarGetUbGlobal(), SCIPvarIsBinary(), SCIPvarIsImpliedIntegral(), SCIPvarIsIntegral(), tightenBounds(), and TRUE.

Referenced by SCIP_DECL_CONSPRESOL().

tightenSides()

static SCIP_RETCODE tightenSides ( SCIP *  scip, SCIP_CONS *  cons, int *  nchgsides, SCIP_Bool *  infeasible  )

static

tightens left and right hand side of constraint due to integrality

Parameters

scip	SCIP data structure
cons	linear constraint
nchgsides	pointer to count number of side changes
infeasible	pointer to store whether infeasibility was detected

Definition at line 8884 of file cons_linear.c.

References chgLhs(), chgRhs(), FALSE, NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPconsGetData(), SCIPconsGetName(), SCIPdebugMsg, SCIPfeasCeil(), SCIPfeasFloor(), SCIPinfinity(), SCIPisGT(), SCIPisInfinity(), SCIPisIntegral(), SCIPvarIsIntegral(), and TRUE.

Referenced by SCIP_DECL_CONSPRESOL(), and SCIPupgradeConsLinear().

consdataTightenCoefs()

static SCIP_RETCODE consdataTightenCoefs ( SCIP *  scip, SCIP_CONS *  cons, int *  nchgcoefs, int *  nchgsides  )

static

tightens coefficients of binary, integer, and implied integral variables due to activity bounds in presolving: given an inequality lhs <= a*x + ai*xi <= rhs, with a non-continuous variable li <= xi <= ui let minact := min{a*x + ai*xi}, maxact := max{a*x + ai*xi} (i) ai >= 0: if minact + ai >= lhs and maxact - ai <= rhs: (**)

• a deviation from the lower/upper bound of xi would make the left/right hand side redundant
• ai, lhs and rhs can be changed to have the same redundancy effect and the same results for xi fixed to its bounds, but with a reduced ai and tightened sides to tighten the LP relaxation
• change coefficients: ai' := max(lhs - minact, maxact - rhs, 0) lhs' := lhs - (ai - ai')*li rhs' := rhs - (ai - ai')*ui (ii) ai < 0: if minact - ai >= lhs and maxact + ai <= rhs: (***)
• a deviation from the upper/lower bound of xi would make the left/right hand side redundant
• ai, lhs and rhs can be changed to have the same redundancy effect and the same results for xi fixed to its bounds, but with a reduced ai and tightened sides to tighten the LP relaxation
• change coefficients: ai' := min(rhs - maxact, minact - lhs, 0) lhs' := lhs - (ai - ai')*ui rhs' := rhs - (ai - ai')*li

We further try to remove variables from the constraint; Variables which fulfill conditions (**) or (***) are called relevant variables. A deviation of only one from their bound makes the lhs/rhs feasible (i.e., redundant), even if all other variables are set to their "worst" bound. If all variables which are not relevant cannot make the lhs/rhs redundant, even if they are set to their "best" bound, they can be removed from the constraint. E.g., for binary variables and an inequality x_1 +x_2 +10y_1 +10y_2 >= 5, setting either of the y_i to one suffices to fulfill the inequality, whereas the x_i do not contribute to feasibility and can be removed.

Parameters

scip	SCIP data structure
cons	linear constraint
nchgcoefs	pointer to count total number of changed coefficients
nchgsides	pointer to count number of side changes

Definition at line 9003 of file cons_linear.c.

References chgCoefPos(), chgLhs(), chgRhs(), consdataGetActivityBounds(), delCoefPos(), MAX3, MIN3, NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPallocBufferArray, SCIPconsGetData(), SCIPconsGetName(), SCIPdebugMsg, SCIPfreeBufferArray, SCIPinfinity(), SCIPisEQ(), SCIPisFeasGT(), SCIPisFeasLT(), SCIPisGE(), SCIPisGT(), SCIPisInfinity(), SCIPisLE(), SCIPisLT(), SCIPisSumRelEQ(), SCIPisSumRelGE(), SCIPisSumRelLE(), SCIPisZero(), SCIPvarGetLbLocal(), SCIPvarGetName(), SCIPvarGetUbLocal(), SCIPvarIsIntegral(), and TRUE.

Referenced by SCIP_DECL_CONSPRESOL().

convertUnaryEquality()

static SCIP_RETCODE convertUnaryEquality ( SCIP *  scip, SCIP_CONS *  cons, SCIP_Bool *  cutoff, int *  nfixedvars, int *  ndelconss  )

static

processes equality with only one variable by fixing the variable and deleting the constraint

Parameters

scip	SCIP data structure
cons	linear constraint
cutoff	pointer to store TRUE, if a cutoff was found
nfixedvars	pointer to count number of fixed variables
ndelconss	pointer to count number of deleted constraints

Definition at line 9414 of file cons_linear.c.

References MAXDNOM, NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPconsGetData(), SCIPconsGetName(), SCIPdebugMsg, SCIPdelCons(), SCIPepsilon(), SCIPfixVar(), SCIPisEQ(), SCIPisZero(), SCIPselectSimpleValue(), SCIPvarGetName(), and TRUE.

Referenced by convertEquality().

convertBinaryEquality()

static SCIP_RETCODE convertBinaryEquality ( SCIP *  scip, SCIP_CONS *  cons, SCIP_Bool *  cutoff, int *  naggrvars, int *  ndelconss  )

static

processes equality with exactly two variables by aggregating one of the variables and deleting the constraint

Parameters

scip	SCIP data structure
cons	linear constraint
cutoff	pointer to store TRUE, if a cutoff was found
naggrvars	pointer to count number of aggregated variables
ndelconss	pointer to count number of deleted constraints

Definition at line 9470 of file cons_linear.c.

References NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIPaggregateVars(), SCIPconsGetData(), SCIPconsGetName(), SCIPdebugMsg, SCIPdelCons(), SCIPisEQ(), SCIPvarGetName(), and TRUE.

Referenced by convertEquality().

getNewSidesAfterAggregation()

static void getNewSidesAfterAggregation ( SCIP *  scip, SCIP_CONSDATA *  consdata, SCIP_VAR *  slackvar, SCIP_Real  slackcoef, SCIP_Real *  newlhs, SCIP_Real *  newrhs  )

static

calculates the new lhs and rhs of the constraint after the given variable is aggregated out

Parameters

scip	SCIP data structure
consdata	linear constraint data
slackvar	variable to be aggregated out
slackcoef	coefficient of variable in constraint
newlhs	pointer to store new lhs of constraint
newrhs	pointer to store new rhs of constraint

Definition at line 9528 of file cons_linear.c.

References NULL, SCIP_Real, SCIPinfinity(), SCIPisInfinity(), SCIPisLE(), SCIPvarGetLbGlobal(), and SCIPvarGetUbGlobal().

Referenced by convertLongEquality().

convertLongEquality()

static SCIP_RETCODE convertLongEquality ( SCIP *  scip, SCIP_CONSHDLRDATA *  conshdlrdata, SCIP_CONS *  cons, SCIP_Bool *  cutoff, int *  naggrvars, int *  ndelconss, int *  nchgvartypes  )

static

processes equality with more than two variables by multi-aggregating one of the variables and converting the equality into an inequality; if multi-aggregation is not possible, tries to identify one continuous or integer variable that is implied integral by this constraint

Parameters

scip	SCIP data structure
conshdlrdata	linear constraint handler data
cons	linear constraint
cutoff	pointer to store TRUE, if a cutoff was found
naggrvars	pointer to count number of aggregated variables
ndelconss	pointer to count number of deleted constraints
nchgvartypes	pointer to count number of changed variable types

Definition at line 9582 of file cons_linear.c.

References chgLhs(), chgRhs(), consdataGetActivityResiduals(), consdataGetReliableResidualActivity(), delCoefPos(), FALSE, getNewSidesAfterAggregation(), NULL, REALABS, scalars, SCIP_Bool, SCIP_CALL, SCIP_DEPRECATED_VARTYPE_IMPLINT, SCIP_IMPLINTTYPE_NONE, SCIP_IMPLINTTYPE_STRONG, SCIP_IMPLINTTYPE_WEAK, SCIP_LOCKTYPE_MODEL, SCIP_MAXSTRLEN, SCIP_OKAY, SCIP_Real, SCIP_VARTYPE_BINARY, SCIP_VARTYPE_CONTINUOUS, SCIP_VARTYPE_INTEGER, SCIPaddVar(), SCIPaggregateVars(), SCIPallocBufferArray, SCIPchgVarImplType(), SCIPconsGetData(), SCIPconsGetName(), SCIPconsIsChecked(), SCIPcreateVarImpl(), SCIPdebugAddSolVal, SCIPdebugGetSolVal, SCIPdebugMsg, SCIPdebugMsgPrint, SCIPdebugPrintCons, SCIPdelCons(), SCIPdoNotAggr(), SCIPdoNotMultaggrVar(), SCIPfreeBufferArray, SCIPinfinity(), SCIPisEQ(), SCIPisFeasIntegral(), SCIPisFeasLE(), SCIPisGE(), SCIPisGT(), SCIPisHugeValue(), SCIPisInfinity(), SCIPisIntegral(), SCIPisLE(), SCIPisPositive(), SCIPisUpdateUnreliable(), SCIPisZero(), SCIPmultiaggregateVar(), SCIPreleaseVar(), SCIPsnprintf(), SCIPvarGetImplType(), SCIPvarGetLbGlobal(), SCIPvarGetName(), SCIPvarGetNLocksDownType(), SCIPvarGetNLocksUpType(), SCIPvarGetType(), SCIPvarGetUbGlobal(), SCIPvarIsActive(), SCIPvarIsBinary(), SCIPvarIsInitial(), SCIPvarIsIntegral(), SCIPvarIsRemovable(), and TRUE.

Referenced by convertEquality().

checkEqualObjective()

static SCIP_Bool checkEqualObjective ( SCIP *  scip, SCIP_CONSDATA *  consdata, SCIP_Real *  scale, SCIP_Real *  offset  )

static

checks if the given variables and their coefficient are equal (w.r.t. scaling factor) to the objective function

Parameters

scip	SCIP data structure
consdata	linear constraint data
scale	pointer to store the scaling factor between the constraint and the objective function
offset	pointer to store the offset of the objective function resulting by this constraint

Definition at line 10103 of file cons_linear.c.

References FALSE, NULL, SCIP_Bool, SCIP_Real, SCIPisEQ(), SCIPisZero(), SCIPvarGetNegatedVar(), SCIPvarGetObj(), SCIPvarIsNegated(), and TRUE.

Referenced by checkParallelObjective(), and checkPartialObjective().

checkPartialObjective()

static SCIP_RETCODE checkPartialObjective ( SCIP *  scip, SCIP_CONS *  cons, SCIP_CONSHDLRDATA *  conshdlrdata  )

static

check if the linear equality constraint is equal to a subset of the objective function; if so we can remove the objective coefficients and add an objective offset

Parameters

scip	SCIP data structure
cons	linear equation constraint
conshdlrdata	linear constraint handler data

Definition at line 10181 of file cons_linear.c.

References checkEqualObjective(), NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPaddObjoffset(), SCIPchgVarObj(), SCIPconsGetData(), SCIPconsGetName(), SCIPdebugMsg, SCIPgetNObjVars(), SCIPisEQ(), SCIPsetConsChecked(), SCIPsetConsEnforced(), and TRUE.

Referenced by convertEquality().

updateCutoffbound()

static SCIP_RETCODE updateCutoffbound ( SCIP *  scip, SCIP_CONS *  cons, SCIP_Real  primalbound  )

static

updates the cutoff if the given primal bound (which is implied by the given constraint) is better

Parameters

scip	SCIP data structure
cons	constraint
primalbound	feasible primal bound

Definition at line 10252 of file cons_linear.c.

References FALSE, NULL, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPconsGetData(), SCIPcutoffbounddelta(), SCIPdebugMsg, SCIPgetCutoffbound(), SCIPisInfinity(), SCIPsetConsEnforced(), SCIPsetConsPropagated(), and SCIPupdateCutoffbound().

Referenced by checkParallelObjective().

checkParallelObjective()

static SCIP_RETCODE checkParallelObjective ( SCIP *  scip, SCIP_CONS *  cons, SCIP_CONSHDLRDATA *  conshdlrdata  )

static

check if the linear constraint is parallel to objective function; if so update the cutoff bound and avoid that the constraint enters the LP by setting the initial and separated flag to FALSE

Parameters

scip	SCIP data structure
cons	linear constraint
conshdlrdata	linear constraint handler data

Definition at line 10298 of file cons_linear.c.

References checkEqualObjective(), FALSE, NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPconsGetData(), SCIPconsGetName(), SCIPconsIsInitial(), SCIPconsIsSeparated(), SCIPdebugMsg, SCIPgetNObjVars(), SCIPisEQ(), SCIPisInfinity(), SCIPsetConsInitial(), SCIPsetConsSeparated(), SCIPupdateLocalLowerbound(), and updateCutoffbound().

Referenced by SCIP_DECL_CONSPRESOL().

convertEquality()

static SCIP_RETCODE convertEquality ( SCIP *  scip, SCIP_CONS *  cons, SCIP_CONSHDLRDATA *  conshdlrdata, SCIP_Bool *  cutoff, int *  nfixedvars, int *  naggrvars, int *  ndelconss, int *  nchgvartypes  )

static

converts special equalities

Parameters

scip	SCIP data structure
cons	linear constraint
conshdlrdata	linear constraint handler data
cutoff	pointer to store TRUE, if a cutoff was found
nfixedvars	pointer to count number of fixed variables
naggrvars	pointer to count number of aggregated variables
ndelconss	pointer to count number of deleted constraints
nchgvartypes	pointer to count number of changed variable types

Definition at line 10425 of file cons_linear.c.

References checkPartialObjective(), convertBinaryEquality(), convertLongEquality(), convertUnaryEquality(), NULL, SCIP_CALL, SCIP_OKAY, SCIPconsGetData(), and SCIPisEQ().

Referenced by SCIP_DECL_CONSPRESOL().

consdataIsResidualIntegral()

static SCIP_Bool consdataIsResidualIntegral ( SCIP *  scip, SCIP_CONSDATA *  consdata, int  pos, SCIP_Real  val  )

static

returns whether the linear sum of all variables/coefficients except the given one divided by the given value is always integral

Parameters

scip	SCIP data structure
consdata	linear constraint
pos	position of variable to be left out
val	value to divide the coefficients by

Definition at line 10481 of file cons_linear.c.

References FALSE, NULL, SCIPisIntegral(), SCIPvarIsIntegral(), and TRUE.

Referenced by dualPresolve().

calculateMinvalAndMaxval()

static void calculateMinvalAndMaxval ( SCIP *  scip, SCIP_Real  side, SCIP_Real  val, SCIP_Real  minresactivity, SCIP_Real  maxresactivity, SCIP_Real *  minval, SCIP_Real *  maxval  )

static

check if \(lhs/a_i - \sum_{j \neq i} a_j/a_i x_j\) is always inside the bounds of \(x_i\), check if \(rhs/a_i - \sum_{j \neq i} a_j/a_i x_j\) is always inside the bounds of \(x_i\)

Parameters

scip	SCIP data structure
side	lhs or rhs
val	coefficient
minresactivity	minimal residual activity
maxresactivity	maximal residual activity
minval	pointer to store calculated minval
maxval	pointer to store calculated maxval

Definition at line 10507 of file cons_linear.c.

References ABS, NULL, and SCIPisInfinity().

Referenced by dualPresolve().

dualPresolve()

static SCIP_RETCODE dualPresolve ( SCIP *  scip, SCIP_CONSHDLRDATA *  conshdlrdata, SCIP_CONS *  cons, SCIP_Bool *  cutoff, int *  nfixedvars, int *  naggrvars, int *  ndelconss, int *  nchgvartypes  )

static

applies dual presolving for variables that are locked only once in a direction, and this locking is due to a linear inequality

Parameters

scip	SCIP data structure
conshdlrdata	linear constraint handler data
cons	linear constraint
cutoff	pointer to store TRUE, if a cutoff was found
nfixedvars	pointer to count number of fixed variables
naggrvars	pointer to count number of aggregated variables
ndelconss	pointer to count number of deleted constraints
nchgvartypes	pointer to count number of changed variable types

Definition at line 10552 of file cons_linear.c.

References calculateMinvalAndMaxval(), consdataGetActivityResiduals(), consdataGetReliableResidualActivity(), consdataIsResidualIntegral(), FALSE, NULL, REALABS, SCIP_Bool, SCIP_CALL, SCIP_IMPLINTTYPE_NONE, SCIP_IMPLINTTYPE_STRONG, SCIP_LOCKTYPE_MODEL, SCIP_OKAY, SCIP_Real, SCIP_VARTYPE_CONTINUOUS, SCIP_VARTYPE_INTEGER, SCIPallocBufferArray, SCIPchgVarImplType(), SCIPchgVarType(), SCIPconsGetData(), SCIPconsGetName(), SCIPconsIsChecked(), SCIPdebugMsg, SCIPdebugMsgPrint, SCIPdebugPrintCons, SCIPdelCons(), SCIPdoNotMultaggrVar(), SCIPfloor(), SCIPfreeBufferArray, SCIPinfinity(), SCIPisEQ(), SCIPisFeasGE(), SCIPisFeasLE(), SCIPisGE(), SCIPisInfinity(), SCIPisIntegral(), SCIPisLE(), SCIPisNegative(), SCIPisPositive(), SCIPisUpdateUnreliable(), SCIPisZero(), SCIPmultiaggregateVar(), SCIPvarGetImplType(), SCIPvarGetLbGlobal(), SCIPvarGetName(), SCIPvarGetNLocksDownType(), SCIPvarGetNLocksUpType(), SCIPvarGetObj(), SCIPvarGetType(), SCIPvarGetUbGlobal(), SCIPvarIsBinary(), SCIPvarIsNonimpliedIntegral(), and TRUE.

Referenced by SCIP_DECL_CONSPRESOL().

getVarWeight()

static int getVarWeight ( SCIP_VAR *  var )

static

gets weight for variable in a "weighted number of variables" sum

Parameters

var	variable to get weight for

Definition at line 10984 of file cons_linear.c.

References BINWEIGHT, CONTWEIGHT, INTWEIGHT, SCIP_VARTYPE_BINARY, SCIP_VARTYPE_CONTINUOUS, SCIP_VARTYPE_INTEGER, SCIPABORT, SCIPerrorMessage, SCIPvarGetType(), and SCIPvarIsImpliedIntegral().

Referenced by aggregateConstraints(), and preprocessConstraintPairs().

aggregateVariables()

static SCIP_RETCODE aggregateVariables ( SCIP *  scip, SCIP_CONS *  cons, SCIP_Bool *  cutoff, int *  nfixedvars, int *  naggrvars  )

static

tries to aggregate variables in equations a^Tx = lhs in case there are at most two binary variables with an odd coefficient and all other variables are not continuous and have an even coefficient then:

• exactly one odd binary variables this binary variables y can be fixed to 0 if the lhs is even and to 1 if the lhs is odd
  • lhs is odd -> y = 1
  • lhs is even -> y = 0
• exactly two odd binary variables aggregate the two binary variables with odd coefficient
  • lhs is odd -> exactly one of the variable has to be 1 -> var1 + var2 = 1
  • lhs is even -> both have to take the same value -> var1 - var2 = 0

Parameters

scip	SCIP data structure
cons	linear constraint
cutoff	pointer to store TRUE, if a cutoff was found
nfixedvars	pointer to count number of fixed variables
naggrvars	pointer to count number of aggregated variables

Definition at line 11019 of file cons_linear.c.

References ABS, applyFixings(), FALSE, normalizeCons(), NULL, SCIP_Bool, SCIP_CALL, SCIP_Longint, SCIP_OKAY, SCIP_Real, SCIPaggregateVars(), SCIPconsGetData(), SCIPconsGetName(), SCIPdebugMsg, SCIPfeasFloor(), SCIPfixVar(), SCIPisEQ(), SCIPisInfinity(), SCIPisIntegral(), SCIPvarGetName(), SCIPvarIsBinary(), SCIPvarIsIntegral(), and TRUE.

Referenced by SCIP_DECL_CONSPRESOL().

SCIP_DECL_SORTINDCOMP() [3/3]

static SCIP_DECL_SORTINDCOMP ( consdataCompSim  )

static

sorting method for constraint data, compares two variables on given indices, continuous variables will be sorted to the end and for all other variables the sortation will be in non-increasing order of their absolute value of the coefficients

Definition at line 11190 of file cons_linear.c.

References NULL, REALABS, SCIP_Bool, SCIP_Real, and SCIPvarIsIntegral().

rangedRowSimplify()

static SCIP_RETCODE rangedRowSimplify ( SCIP *  scip, SCIP_CONS *  cons, int *  nchgcoefs, int *  nchgsides  )

static

tries to simplify coefficients in ranged row of the form lhs <= a^Tx <= rhs

1. lhs <= a^Tx <= rhs, x binary, lhs > 0, forall a_i >= lhs, a_i <= rhs, and forall pairs a_i + a_j > rhs, then we can change this constraint to 1^Tx = 1

Parameters

scip	SCIP data structure
cons	linear constraint
nchgcoefs	pointer to store the amount of changed coefficients
nchgsides	pointer to store the amount of changed sides

Definition at line 11227 of file cons_linear.c.

References chgCoefPos(), chgLhs(), chgRhs(), NULL, SCIP_CALL, SCIP_INVALID, SCIP_OKAY, SCIP_Real, SCIPconsGetData(), SCIPconsIsDeleted(), SCIPconsIsModifiable(), SCIPisGE(), SCIPisGT(), SCIPisInfinity(), SCIPisLE(), SCIPisLT(), SCIPisNegative(), SCIPisPositive(), and SCIPvarIsBinary().

Referenced by simplifyInequalities().

simplifyInequalities()

static SCIP_RETCODE simplifyInequalities ( SCIP *  scip, SCIP_CONS *  cons, int *  nchgcoefs, int *  nchgsides, SCIP_Bool *  infeasible  )

static

tries to simplify coefficients and delete variables in constraints of the form lhs <= a^Tx <= rhs

for both-sided constraints only

See also

rangedRowSimplify() will be called

for one-sided constraints there are several different coefficient reduction steps which will be applied

1. We try to determine parts of the constraint which will not change anything on (in-)feasibility of the constraint

   e.g. 5x1 + 5x2 + 3z1 <= 8 => 3z1 is redundant if all x are binary and -2 < 3z1 <= 3

2. We try to remove redundant fractional parts in a constraint

   e.g. 5.2x1 + 5.1x2 + 3x3 <= 8.3 => will be changed to 5x1 + 5x2 + 3x3 <= 8 if all x are binary

3. We are using the greatest common divisor for further reductions

   e.g. 10x1 + 5y2 + 5x3 + 3x4 <= 15 => will be changed to 2x1 + y2 + x3 + x4 <= 3 if all xi are binary and y2 is integral

Parameters

scip	SCIP data structure
cons	linear constraint
nchgcoefs	pointer to store the amount of changed coefficients
nchgsides	pointer to store the amount of changed sides
infeasible	pointer to store whether infeasibility was detected

Definition at line 11339 of file cons_linear.c.

References checkMaxActivityDelta, chgCoefPos(), chgLhs(), chgRhs(), consdataGetGlbActivityBounds(), consdataRecomputeMaxActivityDelta(), delCoefPos(), FALSE, MAXACTVAL, normalizeCons(), NULL, permSortConsdata(), rangedRowSimplify(), REALABS, SCIP_Bool, SCIP_CALL, SCIP_INVALID, SCIP_Longint, SCIP_LONGINT_FORMAT, SCIP_OKAY, SCIP_Real, SCIPallocBufferArray, SCIPcalcGreComDiv(), SCIPceil(), SCIPconsGetData(), SCIPconsGetName(), SCIPconsIsDeleted(), SCIPconsIsModifiable(), SCIPdebug, SCIPdebugMsg, SCIPdebugPrintCons, SCIPfeasCeil(), SCIPfeasFloor(), SCIPfeastol(), SCIPfloor(), SCIPfreeBufferArray, SCIPisEQ(), SCIPisFeasEQ(), SCIPisFeasGE(), SCIPisFeasGT(), SCIPisFeasIntegral(), SCIPisFeasLE(), SCIPisFeasLT(), SCIPisFeasNegative(), SCIPisFeasZero(), SCIPisGE(), SCIPisGT(), SCIPisInfinity(), SCIPisIntegral(), SCIPisLT(), SCIPisNegative(), SCIPisZero(), SCIPsort(), SCIPvarGetLbGlobal(), SCIPvarGetName(), SCIPvarGetUbGlobal(), SCIPvarIsBinary(), SCIPvarIsIntegral(), TRUE, and w.

Referenced by SCIP_DECL_CONSPRESOL().

aggregateConstraints()

static SCIP_RETCODE aggregateConstraints ( SCIP *  scip, SCIP_CONS *  cons0, SCIP_CONS *  cons1, int *  commonidx0, int *  commonidx1, int *  diffidx0minus1, int *  diffidx1minus0, int  nvarscommon, int  commonidxweight, int  diffidx0minus1weight, int  diffidx1minus0weight, SCIP_Real  maxaggrnormscale, int *  nchgcoefs, SCIP_Bool *  aggregated, SCIP_Bool *  infeasible  )

static

tries to aggregate an (in)equality and an equality in order to decrease the number of variables in the (in)equality: cons0 := a * cons0 + b * cons1, where a = val1[v] and b = -val0[v] for common variable v which removes most variable weight; for numerical stability, we will only accept integral a and b; the variable weight is a weighted sum over all included variables, where each binary variable weighs BINWEIGHT, each integer or implied integral variable weighs INTWEIGHT and each continuous variable weighs CONTWEIGHT

Parameters

scip	SCIP data structure
cons0	(in)equality to modify
cons1	equality to use for aggregation of cons0
commonidx0	array with indices of variables in cons0, that appear also in cons1
commonidx1	array with indices of variables in cons1, that appear also in cons0
diffidx0minus1	array with indices of variables in cons0, that don't appear in cons1
diffidx1minus0	array with indices of variables in cons1, that don't appear in cons0
nvarscommon	number of variables, that appear in both constraints
commonidxweight	variable weight sum of common variables
diffidx0minus1weight	variable weight sum of variables in cons0, that don't appear in cons1
diffidx1minus0weight	variable weight sum of variables in cons1, that don't appear in cons0
maxaggrnormscale	maximal allowed relative gain in maximum norm for constraint aggregation
nchgcoefs	pointer to count the number of changed coefficients
aggregated	pointer to store whether an aggregation was made
infeasible	pointer to store whether infeasibility was detected

Definition at line 12572 of file cons_linear.c.

References a, b, consdataGetMaxAbsval(), FALSE, getVarWeight(), normalizeCons(), NULL, REALABS, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPaddConsUpgrade(), SCIPallocBufferArray, SCIPconsGetData(), SCIPconsGetName(), SCIPconsGetNUpgradeLocks(), SCIPconsIsActive(), SCIPconsIsChecked(), SCIPconsIsDynamic(), SCIPconsIsEnforced(), SCIPconsIsInitial(), SCIPconsIsLocal(), SCIPconsIsModifiable(), SCIPconsIsPropagated(), SCIPconsIsRemovable(), SCIPconsIsSeparated(), SCIPconsIsStickingAtNode(), SCIPcreateConsLinear(), SCIPdebug, SCIPdebugMsg, SCIPdebugPrintCons, SCIPdelCons(), SCIPfreeBufferArray, SCIPinfinity(), SCIPisEQ(), SCIPisInfinity(), SCIPisIntegral(), SCIPisLE(), SCIPisPositive(), SCIPisZero(), SCIPreleaseCons(), and TRUE.

Referenced by preprocessConstraintPairs().

SCIP_DECL_HASHGETKEY()

static SCIP_DECL_HASHGETKEY ( hashGetKeyLinearcons  )

static

gets the key of the given element

Definition at line 12888 of file cons_linear.c.

SCIP_DECL_HASHKEYEQ()

static SCIP_DECL_HASHKEYEQ ( hashKeyEqLinearcons  )

static

returns TRUE iff both keys are equal; two constraints are equal if they have the same variables and the coefficients are either equal or negated

Definition at line 12898 of file cons_linear.c.

References consdataGetMaxAbsval(), FALSE, NULL, SCIP_Real, SCIPconsGetData(), SCIPinfinity(), SCIPisLT(), SCIPswapPointers(), SCIPvarCompare(), and TRUE.

SCIP_DECL_HASHKEYVAL()

static SCIP_DECL_HASHKEYVAL ( hashKeyValLinearcons  )

static

returns the hash value of the key

Definition at line 12972 of file cons_linear.c.

References NULL, SCIPconsGetData(), SCIPhashFour, and SCIPvarGetIndex().

getParallelConsKey()

static unsigned int getParallelConsKey ( SCIP_CONS *  cons )

static

returns the key for deciding which of two parallel constraints should be kept (smaller key should be kept); prefers non-upgraded constraints and as second criterion the constraint with the smallest position

Parameters

cons	linear constraint

Definition at line 13004 of file cons_linear.c.

References NULL, SCIPconsGetData(), and SCIPconsGetPos().

Referenced by retrieveParallelConstraints().

retrieveParallelConstraints()

static SCIP_RETCODE retrieveParallelConstraints ( SCIP_HASHTABLE *  hashtable, SCIP_CONS **  querycons, SCIP_CONS **  parallelconss, int *  nparallelconss  )

static

updates the hashtable such that out of all constraints in the hashtable that are detected to be parallel to *querycons, only one is kept in the hashtable and stored into *querycons, and all others are removed from the hashtable and stored in the given array

Parameters

hashtable	hashtable containing linear constraints
querycons	pointer to linear constraint used to look for duplicates in the hash table; upon return will contain the constraint that should be kept
parallelconss	array to return constraints that are parallel to the given; these constraints where removed from the hashtable
nparallelconss	pointer to return number of parallel constraints

Definition at line 13023 of file cons_linear.c.

References getParallelConsKey(), NULL, SCIP_CALL, SCIP_CALL_ABORT, SCIP_OKAY, SCIPhashtableInsert(), SCIPhashtableRemove(), SCIPhashtableRetrieve(), and SCIPhashtableSafeInsert().

Referenced by detectRedundantConstraints().

detectRedundantConstraints()

static SCIP_RETCODE detectRedundantConstraints ( SCIP *  scip, BMS_BLKMEM *  blkmem, SCIP_CONS **  conss, int  nconss, int *  firstchange, SCIP_Bool *  cutoff, int *  ndelconss, int *  nchgsides  )

static

compares each constraint with all other constraints for possible redundancy and removes or changes constraint accordingly; in contrast to preprocessConstraintPairs(), it uses a hash table

Parameters

scip	SCIP data structure
blkmem	block memory
conss	constraint set
nconss	number of constraints in constraint set
firstchange	pointer to store first changed constraint
cutoff	pointer to store TRUE, if a cutoff was found
ndelconss	pointer to count number of deleted constraints
nchgsides	pointer to count number of changed left/right hand sides

Definition at line 13084 of file cons_linear.c.

References chgLhs(), chgRhs(), consdataSort(), COPYSIGN, MAX, MIN, NULL, retrieveParallelConstraints(), SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPallocBufferArray, SCIPconsGetData(), SCIPconsGetName(), SCIPconsGetNUpgradeLocks(), SCIPconsGetPos(), SCIPconsIsActive(), SCIPconsIsModifiable(), SCIPdebugMsg, SCIPdebugPrintCons, SCIPdelCons(), SCIPfreeBufferArray, SCIPgetMessagehdlr(), SCIPhashtableCreate(), SCIPhashtableFree(), SCIPhashtablePrintStatistics(), SCIPinfoMessage(), SCIPisEQ(), SCIPisFeasLT(), SCIPisInfinity(), SCIPisStopped(), SCIPupdateConsFlags(), and TRUE.

Referenced by SCIP_DECL_CONSPRESOL().

preprocessConstraintPairs()

static SCIP_RETCODE preprocessConstraintPairs ( SCIP *  scip, SCIP_CONS **  conss, int  firstchange, int  chkind, SCIP_Real  maxaggrnormscale, SCIP_Bool *  cutoff, int *  ndelconss, int *  nchgsides, int *  nchgcoefs  )

static

compares constraint with all prior constraints for possible redundancy or aggregation, and removes or changes constraint accordingly

Parameters

scip	SCIP data structure
conss	constraint set
firstchange	first constraint that changed since last pair preprocessing round
chkind	index of constraint to check against all prior indices upto startind
maxaggrnormscale	maximal allowed relative gain in maximum norm for constraint aggregation
cutoff	pointer to store TRUE, if a cutoff was found
ndelconss	pointer to count number of deleted constraints
nchgsides	pointer to count number of changed left/right hand sides
nchgcoefs	pointer to count number of changed coefficients

Definition at line 13288 of file cons_linear.c.

References aggregateConstraints(), chgLhs(), chgRhs(), consdataCalcSignatures(), consdataSort(), FALSE, getVarWeight(), MAX, MIN, NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPABORT, SCIPallocBufferArray, SCIPconsGetData(), SCIPconsGetName(), SCIPconsIsActive(), SCIPconsIsModifiable(), SCIPdebugMsg, SCIPdebugPrintCons, SCIPdelCons(), SCIPerrorMessage, SCIPfreeBufferArray, SCIPinfinity(), SCIPisEQ(), SCIPisFeasGT(), SCIPisFeasLT(), SCIPisGE(), SCIPisGT(), SCIPisInfinity(), SCIPisLE(), SCIPisLT(), SCIPisNegative(), SCIPisPositive(), SCIPreallocBufferArray, SCIPupdateConsFlags(), SCIPvarCompare(), SCIPvarGetLbGlobal(), SCIPvarGetUbGlobal(), and TRUE.

Referenced by SCIP_DECL_CONSPRESOL().

presolStuffing()

static SCIP_RETCODE presolStuffing ( SCIP *  scip, SCIP_CONS *  cons, SCIP_Bool  singletonstuffing, SCIP_Bool  singlevarstuffing, SCIP_Bool *  cutoff, int *  nfixedvars, int *  nchgbds  )

static

do stuffing presolving on a single constraint

Parameters

scip	SCIP data structure
cons	linear constraint
singletonstuffing	should stuffing of singleton continuous variables be performed?
singlevarstuffing	should single variable stuffing be performed, which tries to fulfill constraints using the cheapest variable?
cutoff	pointer to store TRUE, if a cutoff was found
nfixedvars	pointer to count the total number of fixed variables
nchgbds	pointer to count the total number of tightened bounds

Definition at line 13892 of file cons_linear.c.

References consdataGetActivityBounds(), FALSE, NULL, REALABS, SCIP_Bool, SCIP_CALL, SCIP_INVALID, SCIP_LOCKTYPE_MODEL, SCIP_OKAY, SCIP_Real, SCIPallocBufferArray, SCIPceil(), SCIPconsGetData(), SCIPconsGetName(), SCIPdebug, SCIPdebugMsg, SCIPfixVar(), SCIPfloor(), SCIPfreeBufferArray, SCIPinfinity(), SCIPisEQ(), SCIPisGT(), SCIPisInfinity(), SCIPisIntegral(), SCIPisLE(), SCIPisNegative(), SCIPisPositive(), SCIPisZero(), SCIPsortRealInt(), SCIPtightenVarLb(), SCIPtightenVarUb(), SCIPvarGetLbGlobal(), SCIPvarGetName(), SCIPvarGetNLocksDownType(), SCIPvarGetNLocksUpType(), SCIPvarGetObj(), SCIPvarGetUbGlobal(), SCIPvarIsIntegral(), and TRUE.

Referenced by SCIP_DECL_CONSPRESOL().

fullDualPresolve()

static SCIP_RETCODE fullDualPresolve ( SCIP *  scip, SCIP_CONS **  conss, int  nconss, SCIP_Bool *  cutoff, int *  nchgbds, int *  nchgvartypes  )

static

applies full dual presolving on variables that only appear in linear constraints

Parameters

scip	SCIP data structure
conss	constraint set
nconss	number of constraints
cutoff	pointer to store TRUE, if a cutoff was found
nchgbds	pointer to count the number of bound changes
nchgvartypes	pointer to count the number of variable type changes

Definition at line 14481 of file cons_linear.c.

References BMSclearMemoryArray, consdataGetGlbActivityResiduals(), consdataGetReliableResidualActivity(), FALSE, MAX, MIN, NULL, REALABS, SCIP_Bool, SCIP_CALL, SCIP_IMPLINTTYPE_WEAK, SCIP_LOCKTYPE_MODEL, SCIP_OKAY, SCIP_Real, SCIP_VARTYPE_BINARY, SCIPallocBufferArray, SCIPceil(), SCIPchgVarImplType(), SCIPconsGetData(), SCIPconsGetNLocksNeg(), SCIPconsGetNLocksPos(), SCIPconsIsLocked(), SCIPconsIsModifiable(), SCIPdebugMsg, SCIPduplicateBufferArray, SCIPfloor(), SCIPfreeBufferArray, SCIPgetNBinVars(), SCIPgetNContVars(), SCIPgetNVars(), SCIPgetVars(), SCIPinfinity(), SCIPinProbing(), SCIPisEQ(), SCIPisHugeValue(), SCIPisInfinity(), SCIPisIntegral(), SCIPisNegative(), SCIPisPositive(), SCIPisUpdateUnreliable(), SCIPisZero(), SCIPtightenVarLb(), SCIPtightenVarUb(), SCIPvarGetLbGlobal(), SCIPvarGetName(), SCIPvarGetNLocksDownType(), SCIPvarGetNLocksUpType(), SCIPvarGetObj(), SCIPvarGetProbindex(), SCIPvarGetType(), SCIPvarGetUbGlobal(), SCIPvarIsBinary(), SCIPvarIsImpliedIntegral(), SCIPvarIsIntegral(), and TRUE.

Referenced by SCIP_DECL_CONSPRESOL().

enforceConstraint()

static SCIP_RETCODE enforceConstraint ( SCIP *  scip, SCIP_CONSHDLR *  conshdlr, SCIP_CONS **  conss, int  nconss, int  nusefulconss, SCIP_SOL *  sol, SCIP_RESULT *  result  )

static

helper function to enforce constraints

Parameters

scip	SCIP data structure
conshdlr	constraint handler
conss	constraints to process
nconss	number of constraints
nusefulconss	number of useful (non-obsolete) constraints to process
sol	solution to enforce (NULL for the LP solution)
result	pointer to store the result of the enforcing call

Definition at line 14956 of file cons_linear.c.

References addRelaxation(), checkCons(), CONSHDLR_NAME, FALSE, NULL, SCIP_Bool, SCIP_CALL, SCIP_CUTOFF, SCIP_FEASIBLE, SCIP_OKAY, SCIP_SEPARATED, SCIPconshdlrGetData(), SCIPconshdlrGetName(), and SCIPdebugMsg.

Referenced by SCIP_DECL_CONSENFOLP(), and SCIP_DECL_CONSENFORELAX().

addSymmetryInformation()

static SCIP_RETCODE addSymmetryInformation ( SCIP *  scip, SYM_SYMTYPE  symtype, SCIP_CONS *  cons, SYM_GRAPH *  graph, SCIP_Bool *  success  )

static

adds symmetry information of constraint to a symmetry detection graph

Parameters

scip	SCIP pointer
symtype	type of symmetries that need to be added
cons	constraint
graph	symmetry detection graph
success	pointer to store whether symmetry information could be added

Definition at line 15028 of file cons_linear.c.

References NULL, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPallocBufferArray, SCIPconsGetData(), SCIPextendPermsymDetectionGraphLinear(), SCIPfreeBufferArray, SCIPgetNVars(), SCIPgetSymActiveVariables(), SCIPisInfinity(), and SCIPisTransformed().

Referenced by SCIP_DECL_CONSGETPERMSYMGRAPH(), and SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH().

SCIP_DECL_CONSHDLRCOPY()

static SCIP_DECL_CONSHDLRCOPY ( conshdlrCopyLinear  )

static

copy method for constraint handler plugins (called when SCIP copies plugins)

Definition at line 15101 of file cons_linear.c.

References CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_OKAY, SCIPconshdlrGetName(), SCIPincludeConshdlrLinear(), and TRUE.

SCIP_DECL_CONSFREE()

static SCIP_DECL_CONSFREE ( consFreeLinear  )

static

destructor of constraint handler to free constraint handler data (called when SCIP is exiting)

Definition at line 15117 of file cons_linear.c.

References CONSHDLR_NAME, conshdlrdataFree(), NULL, SCIP_OKAY, SCIPconshdlrGetData(), SCIPconshdlrGetName(), and SCIPconshdlrSetData().

SCIP_DECL_CONSINIT()

static SCIP_DECL_CONSINIT ( consInitLinear  )

static

initialization method of constraint handler (called after problem was transformed)

Definition at line 15139 of file cons_linear.c.

References consCatchAllEvents(), NULL, SCIP_CALL, SCIP_OKAY, and SCIPconshdlrGetData().

SCIP_DECL_CONSEXIT()

static SCIP_DECL_CONSEXIT ( consExitLinear  )

static

deinitialization method of constraint handler (called before transformed problem is freed)

Definition at line 15167 of file cons_linear.c.

References consDropAllEvents(), NULL, SCIP_CALL, SCIP_OKAY, SCIPconsGetData(), and SCIPconshdlrGetData().

isRangedRow()

static SCIP_Bool isRangedRow ( SCIP *  scip, SCIP_Real  lhs, SCIP_Real  rhs  )

static

is constraint ranged row, i.e., -inf < lhs < rhs < inf?

Parameters

scip	SCIP data structure
lhs	left hand side
rhs	right hand side

Definition at line 15200 of file cons_linear.c.

References NULL, SCIPisEQ(), and SCIPisInfinity().

Referenced by SCIPclassifyConstraintTypesLinear().

isFiniteNonnegativeIntegral()

static SCIP_Bool isFiniteNonnegativeIntegral ( SCIP *  scip, SCIP_Real  x  )

static

is constraint ranged row, i.e., -inf < lhs < rhs < inf?

Parameters

scip	SCIP data structure
x	value

Definition at line 15213 of file cons_linear.c.

References NULL, SCIPisInfinity(), SCIPisIntegral(), SCIPisNegative(), and x.

Referenced by SCIPclassifyConstraintTypesLinear().

SCIP_DECL_CONSEXITPRE()

static SCIP_DECL_CONSEXITPRE ( consExitpreLinear  )

static

presolving deinitialization method of constraint handler (called after presolving has been finished)

Definition at line 15572 of file cons_linear.c.

References applyFixings(), consdataRecomputeMaxActivityDelta(), NULL, SCIP_CALL, SCIP_OKAY, SCIPconsGetData(), SCIPconshdlrGetData(), SCIPconsIsDeleted(), SCIPdelCons(), SCIPisLT(), and SCIPstatisticMessage.

SCIP_DECL_CONSINITSOL()

static SCIP_DECL_CONSINITSOL ( consInitsolLinear  )

static

solving process initialization method of constraint handler

Definition at line 15649 of file cons_linear.c.

References addNlrow(), SCIP_CALL, SCIP_OKAY, and SCIPisNLPConstructed().

SCIP_DECL_CONSEXITSOL()

static SCIP_DECL_CONSEXITSOL ( consExitsolLinear  )

static

solving process deinitialization method of constraint handler (called before branch and bound process data is freed)

Definition at line 15666 of file cons_linear.c.

References NULL, SCIP_CALL, SCIP_OKAY, SCIP_VERBLEVEL_HIGH, SCIPconsGetData(), SCIPconvertCutsToConss(), SCIPreleaseNlRow(), SCIPreleaseRow(), SCIPverbMessage(), and TRUE.

SCIP_DECL_CONSACTIVE()

static SCIP_DECL_CONSACTIVE ( consActiveLinear  )

static

constraint activation notification method of constraint handler

Definition at line 15718 of file cons_linear.c.

References addNlrow(), NULL, SCIP_CALL, SCIP_OKAY, SCIP_STAGE_SOLVING, SCIPgetStage(), and SCIPisNLPConstructed().

SCIP_DECL_CONSDEACTIVE()

static SCIP_DECL_CONSDEACTIVE ( consDeactiveLinear  )

static

constraint deactivation notification method of constraint handler

Definition at line 15732 of file cons_linear.c.

References consDropAllEvents(), CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_OKAY, SCIP_STAGE_SOLVING, SCIPconsGetData(), SCIPconshdlrGetData(), SCIPconshdlrGetName(), SCIPconsIsDeleted(), SCIPdelNlRow(), and SCIPgetStage().

SCIP_DECL_CONSDELETE()

static SCIP_DECL_CONSDELETE ( consDeleteLinear  )

static

frees specific constraint data

Definition at line 15777 of file cons_linear.c.

References consdataFree(), consDropAllEvents(), CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_OKAY, SCIPconshdlrGetData(), and SCIPconshdlrGetName().

SCIP_DECL_CONSTRANS()

static SCIP_DECL_CONSTRANS ( consTransLinear  )

static

transforms constraint data into data belonging to the transformed problem

Definition at line 15804 of file cons_linear.c.

References consdataCreate(), CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_OKAY, SCIP_STAGE_TRANSFORMING, SCIPconsGetData(), SCIPconsGetName(), SCIPconshdlrGetName(), SCIPconsIsChecked(), SCIPconsIsDynamic(), SCIPconsIsEnforced(), SCIPconsIsInitial(), SCIPconsIsLocal(), SCIPconsIsModifiable(), SCIPconsIsPropagated(), SCIPconsIsRemovable(), SCIPconsIsSeparated(), SCIPconsIsStickingAtNode(), SCIPcreateCons(), SCIPgetStage(), and SCIPvarIsRelaxationOnly().

SCIP_DECL_CONSINITLP()

static SCIP_DECL_CONSINITLP ( consInitlpLinear  )

static

LP initialization method of constraint handler (called before the initial LP relaxation at a node is solved)

Definition at line 15849 of file cons_linear.c.

References addRelaxation(), CONSHDLR_NAME, FALSE, NULL, SCIP_CALL, SCIP_OKAY, SCIPconshdlrGetName(), and SCIPconsIsInitial().

SCIP_DECL_CONSSEPALP()

static SCIP_DECL_CONSSEPALP ( consSepalpLinear  )

static

separation method of constraint handler for LP solutions

Definition at line 15870 of file cons_linear.c.

References CONSHDLR_NAME, FALSE, NULL, SCIP_Bool, SCIP_CALL, SCIP_CUTOFF, SCIP_DIDNOTFIND, SCIP_DIDNOTRUN, SCIP_OKAY, SCIP_Real, SCIP_SEPARATED, SCIPconshdlrGetData(), SCIPconshdlrGetName(), SCIPgetCutoffbound(), SCIPgetDepth(), SCIPgetLocalLowerbound(), SCIPgetLowerbound(), SCIPgetNLPBranchCands(), SCIPgetNSepaRounds(), SCIPisLE(), and separateCons().

SCIP_DECL_CONSSEPASOL()

static SCIP_DECL_CONSSEPASOL ( consSepasolLinear  )

static

separation method of constraint handler for arbitrary primal solutions

Definition at line 15941 of file cons_linear.c.

References CONSHDLR_NAME, FALSE, NULL, SCIP_Bool, SCIP_CALL, SCIP_CUTOFF, SCIP_DIDNOTFIND, SCIP_DIDNOTRUN, SCIP_OKAY, SCIP_SEPARATED, SCIPconshdlrGetData(), SCIPconshdlrGetName(), SCIPgetDepth(), SCIPgetNSepaRounds(), separateCons(), and TRUE.

SCIP_DECL_CONSENFOLP()

static SCIP_DECL_CONSENFOLP ( consEnfolpLinear  )

static

constraint enforcing method of constraint handler for LP solutions

Definition at line 15999 of file cons_linear.c.

References enforceConstraint(), NULL, SCIP_CALL, and SCIP_OKAY.

SCIP_DECL_CONSENFORELAX()

static SCIP_DECL_CONSENFORELAX ( consEnforelaxLinear  )

static

constraint enforcing method of constraint handler for relaxation solutions

Definition at line 16008 of file cons_linear.c.

References enforceConstraint(), SCIP_CALL, and SCIP_OKAY.

SCIP_DECL_CONSENFOPS()

static SCIP_DECL_CONSENFOPS ( consEnfopsLinear  )

static

constraint enforcing method of constraint handler for pseudo solutions

Definition at line 16017 of file cons_linear.c.

References checkCons(), CONSHDLR_NAME, FALSE, NULL, SCIP_Bool, SCIP_CALL, SCIP_DIDNOTRUN, SCIP_FEASIBLE, SCIP_INFEASIBLE, SCIP_OKAY, SCIPconshdlrGetData(), SCIPconshdlrGetName(), SCIPdebugMsg, and TRUE.

SCIP_DECL_CONSCHECK()

static SCIP_DECL_CONSCHECK ( consCheckLinear  )

static

feasibility check method of constraint handler for integral solutions

Definition at line 16065 of file cons_linear.c.

References ABS, checkCons(), consdataGetActivity(), CONSHDLR_NAME, consPrintConsSol(), FALSE, NULL, SCIP_Bool, SCIP_CALL, SCIP_FEASIBLE, SCIP_INFEASIBLE, SCIP_INVALID, SCIP_OKAY, SCIP_Real, SCIPconsGetData(), SCIPconshdlrGetData(), SCIPconshdlrGetName(), SCIPinfoMessage(), SCIPisFeasGT(), SCIPisFeasLT(), and SCIPisInfinity().

SCIP_DECL_CONSPROP()

static SCIP_DECL_CONSPROP ( consPropLinear  )

static

domain propagation method of constraint handler

Definition at line 16124 of file cons_linear.c.

References CONSHDLR_NAME, FALSE, NULL, propagateCons(), SCIP_Bool, SCIP_CALL, SCIP_CUTOFF, SCIP_DIDNOTFIND, SCIP_OKAY, SCIP_REDUCEDDOM, SCIPconshdlrGetData(), SCIPconshdlrGetName(), SCIPconshdlrGetPropFreq(), SCIPgetDepth(), SCIPinProbing(), SCIPinRepropagation(), SCIPunmarkConsPropagate(), and TRUE.

SCIP_DECL_CONSPRESOL()

static SCIP_DECL_CONSPRESOL ( consPresolLinear  )

static

presolving method of constraint handler

Definition at line 16195 of file cons_linear.c.

References aggregateVariables(), applyFixings(), checkParallelObjective(), chgLhs(), chgRhs(), consCatchAllEvents(), consdataGetActivityBounds(), consdataRecomputeMaxactivity(), consdataRecomputeMinactivity(), consdataTightenCoefs(), CONSHDLR_NAME, convertEquality(), detectRedundantConstraints(), dualPresolve(), extractCliques(), FALSE, fixVariables(), fullDualPresolve(), MAXCONSPRESOLROUNDS, MAXVALRECOMP, MINVALRECOMP, normalizeCons(), NULL, preprocessConstraintPairs(), presolStuffing(), rangedRowPropagation(), SCIP_Bool, SCIP_CALL, SCIP_CUTOFF, SCIP_DIDNOTFIND, SCIP_Longint, SCIP_OKAY, SCIP_PRESOLTIMING_EXHAUSTIVE, SCIP_Real, SCIP_SUCCESS, SCIPaddConsUpgrade(), SCIPallocBufferArray, SCIPallowStrongDualReds(), SCIPblkmem(), SCIPconsGetData(), SCIPconsGetName(), SCIPconshdlrGetData(), SCIPconshdlrGetName(), SCIPconsIsActive(), SCIPconsIsChecked(), SCIPconsIsMarkedPropagate(), SCIPconsIsModifiable(), SCIPdebugMsg, SCIPdebugPrintCons, SCIPdelCons(), SCIPfreeBufferArray, SCIPgetNRuns(), SCIPinfinity(), SCIPisEQ(), SCIPisFeasGT(), SCIPisFeasLT(), SCIPisGE(), SCIPisInfinity(), SCIPisLE(), SCIPisLT(), SCIPisPresolveFinished(), SCIPisStopped(), SCIPunmarkConsPropagate(), SCIPupgradeConsLinear(), simplifyInequalities(), tightenBounds(), tightenSides(), and TRUE.

SCIP_DECL_CONSRESPROP()

static SCIP_DECL_CONSRESPROP ( consRespropLinear  )

static

propagation conflict resolving method of constraint handler

Definition at line 16714 of file cons_linear.c.

References intToInferInfo(), NULL, resolvePropagation(), SCIP_CALL, and SCIP_OKAY.

SCIP_DECL_CONSLOCK()

static SCIP_DECL_CONSLOCK ( consLockLinear  )

static

variable rounding lock method of constraint handler

Definition at line 16728 of file cons_linear.c.

References NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIPaddVarLocksType(), SCIPconsGetData(), SCIPisInfinity(), and SCIPisPositive().

SCIP_DECL_CONSDELVARS()

static SCIP_DECL_CONSDELVARS ( consDelvarsLinear  )

static

variable deletion method of constraint handler

Definition at line 16776 of file cons_linear.c.

References NULL, performVarDeletions(), SCIP_CALL, and SCIP_OKAY.

SCIP_DECL_CONSPRINT()

static SCIP_DECL_CONSPRINT ( consPrintLinear  )

static

constraint display method of constraint handler

Definition at line 16792 of file cons_linear.c.

References consdataPrint(), NULL, SCIP_CALL, SCIP_OKAY, and SCIPconsGetData().

SCIP_DECL_CONSCOPY()

static SCIP_DECL_CONSCOPY ( consCopyLinear  )

static

constraint copying method of constraint handler

Definition at line 16805 of file cons_linear.c.

References FALSE, NULL, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPconsGetName(), SCIPcopyConsLinear(), SCIPgetLhsLinear(), SCIPgetNVarsLinear(), SCIPgetRhsLinear(), SCIPgetValsLinear(), SCIPgetVarsLinear(), and separate().

findOperators()

static void findOperators ( const char *  str, char **  firstoperator, char **  secondoperator, SCIP_Bool *  success  )

static

find operators '<=', '==', '>=', [free] in input string and return those places

There should only be one operator, except for ranged rows for which exactly two operators '<=' must be present.

Parameters

str	null terminated input string
firstoperator	pointer to store the string starting at the first operator
secondoperator	pointer to store the string starting at the second operator
success	pointer to store if the line contains a valid operator order

Definition at line 16841 of file cons_linear.c.

References FALSE, NULL, SCIP_Bool, SCIPerrorMessage, and TRUE.

Referenced by SCIP_DECL_CONSPARSE().

SCIP_DECL_CONSPARSE()

static SCIP_DECL_CONSPARSE ( consParseLinear  )

static

constraint parsing method of constraint handler

Definition at line 16940 of file cons_linear.c.

References FALSE, findOperators(), NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_READERROR, SCIP_Real, SCIPallocBufferArray, SCIPcreateConsLinear(), SCIPerrorMessage, SCIPfreeBufferArray, SCIPinfinity(), SCIPparseReal(), SCIPparseVarsLinearsum(), SCIPreallocBufferArray, SCIPskipSpace(), and separate().

SCIP_DECL_CONSGETVARS()

static SCIP_DECL_CONSGETVARS ( consGetVarsLinear  )

static

constraint method of constraint handler which returns the variables (if possible)

Definition at line 17094 of file cons_linear.c.

References BMScopyMemoryArray, FALSE, NULL, SCIP_OKAY, SCIPconsGetData(), and TRUE.

SCIP_DECL_CONSGETNVARS()

static SCIP_DECL_CONSGETNVARS ( consGetNVarsLinear  )

static

! [Callback for the number of variables] constraint method of constraint handler which returns the number of variables (if possible)

Definition at line 17117 of file cons_linear.c.

References NULL, SCIP_OKAY, SCIPconsGetData(), and TRUE.

SCIP_DECL_CONSGETPERMSYMGRAPH()

static SCIP_DECL_CONSGETPERMSYMGRAPH ( consGetPermsymGraphLinear  )

static

! [Callback for the number of variables] constraint handler method which returns the permutation symmetry detection graph of a constraint

Definition at line 17133 of file cons_linear.c.

References addSymmetryInformation(), SCIP_CALL, SCIP_OKAY, and SYM_SYMTYPE_PERM.

SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH()

static SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH ( consGetSignedPermsymGraphLinear  )

static

constraint handler method which returns the signed permutation symmetry detection graph of a constraint

Definition at line 17142 of file cons_linear.c.

References addSymmetryInformation(), SCIP_CALL, SCIP_OKAY, and SYM_SYMTYPE_SIGNPERM.

SCIP_DECL_EVENTEXEC()

static SCIP_DECL_EVENTEXEC ( eventExecLinear  )

static

execution method of event handler

Definition at line 17155 of file cons_linear.c.

References consdataInvalidateActivities(), consdataUpdateActivitiesGlbLb(), consdataUpdateActivitiesGlbUb(), consdataUpdateActivitiesLb(), consdataUpdateActivitiesUb(), EVENTHDLR_NAME, FALSE, NULL, REALABS, SCIP_CALL, SCIP_EVENTTYPE_BOUNDCHANGED, SCIP_EVENTTYPE_BOUNDRELAXED, SCIP_EVENTTYPE_BOUNDTIGHTENED, SCIP_EVENTTYPE_DISABLED, SCIP_EVENTTYPE_FORMAT, SCIP_EVENTTYPE_GBDCHANGED, SCIP_EVENTTYPE_GLBCHANGED, SCIP_EVENTTYPE_GUBCHANGED, SCIP_EVENTTYPE_IMPLTYPECHANGED, SCIP_EVENTTYPE_LBCHANGED, SCIP_EVENTTYPE_LBTIGHTENED, SCIP_EVENTTYPE_TYPECHANGED, SCIP_EVENTTYPE_UBCHANGED, SCIP_EVENTTYPE_UBTIGHTENED, SCIP_EVENTTYPE_VARDELETED, SCIP_EVENTTYPE_VARFIXED, SCIP_EVENTTYPE_VARUNLOCKED, SCIP_IMPLINTTYPE_NONE, SCIP_INVALID, SCIP_INVALIDDATA, SCIP_LOCKTYPE_MODEL, SCIP_OKAY, SCIP_Real, SCIP_STAGE_INITSOLVE, SCIP_STAGE_PRESOLVED, SCIP_VARTYPE_CONTINUOUS, SCIPconsGetData(), SCIPconsIsActive(), SCIPconsIsDeleted(), SCIPerrorMessage, SCIPeventGetNewbound(), SCIPeventGetOldbound(), SCIPeventGetOldImpltype(), SCIPeventGetOldtype(), SCIPeventGetType(), SCIPeventGetVar(), SCIPeventhdlrGetName(), SCIPgetStage(), SCIPisGT(), SCIPisInfinity(), SCIPmarkConsPropagate(), SCIPvarGetLbGlobal(), SCIPvarGetLbLocal(), SCIPvarGetNLocksDownType(), SCIPvarGetNLocksUpType(), SCIPvarGetType(), SCIPvarGetUbGlobal(), SCIPvarGetUbLocal(), SCIPvarIsBinary(), SCIPvarIsImpliedIntegral(), and TRUE.

SCIP_DECL_CONFLICTEXEC()

static SCIP_DECL_CONFLICTEXEC ( conflictExecLinear  )

static

conflict processing method of conflict handler (called when conflict was found)

Definition at line 17361 of file cons_linear.c.

References CONFLICTHDLR_NAME, FALSE, NULL, SCIP_CALL, SCIP_CONSADDED, SCIP_DIDNOTFIND, SCIP_DIDNOTRUN, SCIP_LONGINT_FORMAT, SCIP_MAXSTRLEN, SCIP_OKAY, SCIP_Real, SCIPaddConflict(), SCIPallocBufferArray, SCIPbdchginfoGetNewbound(), SCIPbdchginfoGetVar(), SCIPconflicthdlrGetName(), SCIPcreateConsLinear(), SCIPfreeBufferArray, SCIPgetNConflictConssApplied(), SCIPinfinity(), SCIPreleaseCons(), SCIPsnprintf(), SCIPupgradeConsLinear(), SCIPvarIsBinary(), separate(), and TRUE.

SCIP_DECL_NONLINCONSUPGD()

static SCIP_DECL_NONLINCONSUPGD ( upgradeConsNonlinear  )

static

tries to upgrade a nonlinear constraint into a linear constraint

Definition at line 17447 of file cons_linear.c.

References consdataEnsureVarsSize(), NULL, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPaddCoefLinear(), SCIPconsGetData(), SCIPconsGetName(), SCIPconsIsChecked(), SCIPconsIsDynamic(), SCIPconsIsEnforced(), SCIPconsIsInitial(), SCIPconsIsLocal(), SCIPconsIsModifiable(), SCIPconsIsPropagated(), SCIPconsIsRemovable(), SCIPconsIsSeparated(), SCIPconsIsStickingAtNode(), SCIPcreateConsLinear(), SCIPdebugMsg, SCIPdebugPrintCons, SCIPexprGetChildren(), SCIPexprGetNChildren(), SCIPgetCoefsExprSum(), SCIPgetConstantExprSum(), SCIPgetExprNonlinear(), SCIPgetLhsNonlinear(), SCIPgetRhsNonlinear(), SCIPgetVarExprVar(), SCIPinfinity(), SCIPisExprSum(), SCIPisExprVar(), SCIPisInfinity(), and TRUE.