Scippy

SCIP

Solving Constraint Integer Programs

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_knapsack.h"
#include "scip/cons_linear.h"
#include "scip/cons_nonlinear.h"
#include "scip/cons_quadratic.h"
#include "scip/debug.h"
#include "scip/pub_conflict.h"
#include "scip/pub_cons.h"
#include "scip/pub_event.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 <ctype.h>
#include <string.h>
#include <strings.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 MAXDNOM   10000LL
 
#define MAXSCALEDCOEF   0
 
#define MAXSCALEDCOEFINTEGER   0
 
#define MAXVALRECOMP   1e+06
 
#define MINVALRECOMP   1e-05
 
#define QUADCONSUPGD_PRIORITY   1000000
 
#define NONLINCONSUPGD_PRIORITY   1000000
 
#define checkMaxActivityDelta(scip, consdata)
 
#define MAXTIGHTENROUNDS   10
 
#define MAX_CLIQUE_NONZEROS_PER_CONS   1000000
 
#define MAXMULTIAGGRQUOTIENT   1e+03
 
#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_1,
  PROPRULE_2,
  PROPRULE_3,
  PROPRULE_4,
  PROPRULE_INVALID,
  PROPRULE_INVALID = 0,
  PROPRULE_1 = 1,
  PROPRULE_2 = 2,
  PROPRULE_3 = 3,
  PROPRULE_4 = 4,
  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,
  PROPRULE_2,
  PROPRULE_3,
  PROPRULE_4,
  PROPRULE_INVALID,
  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 *isrelax, 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 *isrelax, SCIP_Bool *issettoinfinity)
 
static void consdataGetActivityBounds (SCIP *scip, SCIP_CONSDATA *consdata, SCIP_Bool goodrelax, SCIP_Real *minactivity, SCIP_Real *maxactivity, SCIP_Bool *minisrelax, SCIP_Bool *maxisrelax)
 
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 *minisrelax, SCIP_Bool *maxisrelax, 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 *minisrelax, SCIP_Bool *maxisrelax, 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 *minisrelax, SCIP_Bool *maxisrelax, 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 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 *scip, 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 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)
 
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)
 
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_CONS *cons, SCIP_Bool *cutoff, int *nfixedvars, int *naggrvars, int *ndelconss)
 
static int getVarWeight (SCIP_VAR *var)
 
static SCIP_RETCODE aggregateVariables (SCIP *scip, SCIP_CONS *cons, SCIP_Bool *cutoff, int *nfixedvars, int *naggrvars, int *ndelconss)
 
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)
 
static SCIP_RETCODE enforceConstraint (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, int nusefulconss, SCIP_SOL *sol, SCIP_RESULT *result)
 
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_CONSEXITSOL (consExitsolLinear)
 
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 SCIP_RETCODE 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_EVENTEXEC (eventExecLinear)
 
static SCIP_DECL_CONFLICTEXEC (conflictExecLinear)
 
static SCIP_DECL_QUADCONSUPGD (upgradeConsQuadratic)
 
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_RealSCIPgetValsLinear (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_ROWSCIPgetRowLinear (SCIP *scip, SCIP_CONS *cons)
 
SCIP_RETCODE SCIPupgradeConsLinear (SCIP *scip, SCIP_CONS *cons, SCIP_CONS **upgdcons)
 

Macro Definition Documentation

◆ CONSHDLR_NAME

◆ CONSHDLR_DESC

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

Definition at line 90 of file cons_linear.c.

◆ CONSHDLR_SEPAPRIORITY

#define CONSHDLR_SEPAPRIORITY   +100000

priority of the constraint handler for separation

Definition at line 91 of file cons_linear.c.

◆ CONSHDLR_ENFOPRIORITY

#define CONSHDLR_ENFOPRIORITY   -1000000

priority of the constraint handler for constraint enforcing

Definition at line 92 of file cons_linear.c.

◆ CONSHDLR_CHECKPRIORITY

#define CONSHDLR_CHECKPRIORITY   -1000000

priority of the constraint handler for checking feasibility

Definition at line 93 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 94 of file cons_linear.c.

◆ CONSHDLR_PROPFREQ

#define CONSHDLR_PROPFREQ   1

frequency for propagating domains; zero means only preprocessing propagation

Definition at line 95 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 96 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 99 of file cons_linear.c.

◆ CONSHDLR_DELAYSEPA

#define CONSHDLR_DELAYSEPA   FALSE

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

Definition at line 100 of file cons_linear.c.

◆ CONSHDLR_DELAYPROP

#define CONSHDLR_DELAYPROP   FALSE

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

Definition at line 101 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 102 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 104 of file cons_linear.c.

◆ CONSHDLR_PROP_TIMING

#define CONSHDLR_PROP_TIMING   SCIP_PROPTIMING_BEFORELP

Definition at line 105 of file cons_linear.c.

◆ EVENTHDLR_NAME

#define EVENTHDLR_NAME   "linear"

Definition at line 107 of file cons_linear.c.

Referenced by SCIP_DECL_CONSGETNVARS(), and SCIP_DECL_NONLINCONSUPGD().

◆ EVENTHDLR_DESC

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

Definition at line 108 of file cons_linear.c.

Referenced by SCIP_DECL_NONLINCONSUPGD().

◆ CONFLICTHDLR_NAME

#define CONFLICTHDLR_NAME   "linear"

Definition at line 110 of file cons_linear.c.

Referenced by SCIP_DECL_NONLINCONSUPGD().

◆ CONFLICTHDLR_DESC

#define CONFLICTHDLR_DESC   "conflict handler creating linear constraints"

Definition at line 111 of file cons_linear.c.

Referenced by SCIP_DECL_NONLINCONSUPGD().

◆ CONFLICTHDLR_PRIORITY

#define CONFLICTHDLR_PRIORITY   -1000000

Definition at line 112 of file cons_linear.c.

Referenced by SCIP_DECL_NONLINCONSUPGD().

◆ DEFAULT_TIGHTENBOUNDSFREQ

#define DEFAULT_TIGHTENBOUNDSFREQ   1

multiplier on propagation frequency, how often the bounds are tightened

Definition at line 114 of file cons_linear.c.

◆ DEFAULT_MAXROUNDS

#define DEFAULT_MAXROUNDS   5

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

Definition at line 115 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 116 of file cons_linear.c.

◆ DEFAULT_MAXSEPACUTS

#define DEFAULT_MAXSEPACUTS   50

maximal number of cuts separated per separation round

Definition at line 117 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 118 of file cons_linear.c.

◆ DEFAULT_PRESOLPAIRWISE

#define DEFAULT_PRESOLPAIRWISE   TRUE

should pairwise constraint comparison be performed in presolving?

Definition at line 119 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 120 of file cons_linear.c.

◆ DEFAULT_NMINCOMPARISONS

#define DEFAULT_NMINCOMPARISONS   200000

number for minimal pairwise presolving comparisons

Definition at line 121 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 122 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 125 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 128 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 131 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 134 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 137 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 143 of file cons_linear.c.

◆ DEFAULT_SIMPLIFYINEQUALITIES

#define DEFAULT_SIMPLIFYINEQUALITIES   TRUE

should presolving try to simplify inequalities

Definition at line 144 of file cons_linear.c.

◆ DEFAULT_DUALPRESOLVING

#define DEFAULT_DUALPRESOLVING   TRUE

should dual presolving steps be performed?

Definition at line 145 of file cons_linear.c.

◆ DEFAULT_SINGLETONSTUFFING

#define DEFAULT_SINGLETONSTUFFING   TRUE

should stuffing of singleton continuous variables be performed?

Definition at line 146 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 147 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 150 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 155 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 160 of file cons_linear.c.

◆ DEFAULT_RANGEDROWPROPAGATION

#define DEFAULT_RANGEDROWPROPAGATION   TRUE

should we perform ranged row propagation

Definition at line 163 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 164 of file cons_linear.c.

◆ DEFAULT_RANGEDROWMAXDEPTH

#define DEFAULT_RANGEDROWMAXDEPTH   INT_MAX

maximum depth to apply ranged row propagation

Definition at line 165 of file cons_linear.c.

◆ DEFAULT_RANGEDROWFREQ

#define DEFAULT_RANGEDROWFREQ   1

frequency for applying ranged row propagation

Definition at line 166 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 168 of file cons_linear.c.

◆ MAXDNOM

#define MAXDNOM   10000LL

maximal denominator for simple rational fixed values

Definition at line 172 of file cons_linear.c.

Referenced by buildFlowCover(), and SCIP_DECL_PRESOLEXEC().

◆ MAXSCALEDCOEF

#define MAXSCALEDCOEF   0

maximal coefficient value after scaling

Definition at line 173 of file cons_linear.c.

◆ MAXSCALEDCOEFINTEGER

#define MAXSCALEDCOEFINTEGER   0

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

Definition at line 174 of file cons_linear.c.

◆ MAXVALRECOMP

#define MAXVALRECOMP   1e+06

maximal abolsute value we trust without recomputing the activity

Definition at line 180 of file cons_linear.c.

◆ MINVALRECOMP

#define MINVALRECOMP   1e-05

minimal abolsute value we trust without recomputing the activity

Definition at line 181 of file cons_linear.c.

◆ QUADCONSUPGD_PRIORITY

#define QUADCONSUPGD_PRIORITY   1000000

priority of the constraint handler for upgrading of quadratic constraints

Definition at line 184 of file cons_linear.c.

◆ NONLINCONSUPGD_PRIORITY

#define NONLINCONSUPGD_PRIORITY   1000000

priority of the constraint handler for upgrading of nonlinear constraints

Definition at line 185 of file cons_linear.c.

◆ checkMaxActivityDelta

#define checkMaxActivityDelta (   scip,
  consdata 
)

Definition at line 1531 of file cons_linear.c.

Referenced by consdataCheckNonbinvar().

◆ 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 7786 of file cons_linear.c.

◆ MAXMULTIAGGRQUOTIENT

#define MAXMULTIAGGRQUOTIENT   1e+03

Definition at line 9527 of file cons_linear.c.

◆ BINWEIGHT

#define BINWEIGHT   1

Definition at line 10956 of file cons_linear.c.

◆ INTWEIGHT

#define INTWEIGHT   4

Definition at line 10957 of file cons_linear.c.

◆ CONTWEIGHT

#define CONTWEIGHT   8

Definition at line 10958 of file cons_linear.c.

◆ MAXCONSPRESOLROUNDS

#define MAXCONSPRESOLROUNDS   10

Definition at line 16012 of file cons_linear.c.

Typedef Documentation

◆ PROPRULE

typedef enum Proprule PROPRULE

Definition at line 356 of file cons_linear.c.

◆ INFERINFO

typedef struct InferInfo INFERINFO

Definition at line 371 of file cons_linear.c.

Enumeration Type Documentation

◆ Proprule

enum Proprule
Enumerator
PROPRULE_1 

left hand side and bounds on z -> lower bound on x

PROPRULE_2 

left hand side and upper bound on x -> bound on z

PROPRULE_3 

right hand side and bounds on z -> upper bound on x

PROPRULE_4 

right hand side and lower bound on x -> bound on z

PROPRULE_INVALID 

propagation was applied without a specific propagation rule

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_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 

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 346 of file cons_linear.c.

Function Documentation

◆ intToInferInfo()

static INFERINFO intToInferInfo ( int  i)
static

converts an integer into an inference information

Parameters
iinteger to convert

Definition at line 375 of file cons_linear.c.

◆ inferInfoToInt()

static int inferInfoToInt ( INFERINFO  inferinfo)
static

converts an inference information into an int

Parameters
inferinfoinference information to convert

Definition at line 388 of file cons_linear.c.

Referenced by getInferInfo().

◆ inferInfoGetProprule()

static int inferInfoGetProprule ( INFERINFO  inferinfo)
static

returns the propagation rule stored in the inference information

Parameters
inferinfoinference information to convert

Definition at line 397 of file cons_linear.c.

◆ inferInfoGetPos()

static int inferInfoGetPos ( INFERINFO  inferinfo)
static

returns the position stored in the inference information

Parameters
inferinfoinference information to convert

Definition at line 406 of file cons_linear.c.

◆ getInferInfo()

static INFERINFO getInferInfo ( PROPRULE  proprule,
int  pos 
)
static

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

Parameters
proprulepropagation rule that deduced the value
posvariable position, the propagation rule was applied at

Definition at line 415 of file cons_linear.c.

References conshdlrdataEnsureLinconsupgradesSize(), and inferInfoToInt().

◆ 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
proprulepropagation rule that deduced the value
posvariable position, the propagation rule was applied at

Definition at line 434 of file cons_linear.c.

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

◆ conshdlrdataEnsureLinconsupgradesSize()

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

ensures, that linconsupgrades array can store at least num entries

Parameters
scipSCIP data structure
conshdlrdatalinear constraint handler data
numminimum number of entries to store

Definition at line 449 of file cons_linear.c.

Referenced by conshdlrdataHasUpgrade(), and getInferInfo().

◆ 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
scipSCIP data structure
consdatalinear constraint data
numminimum number of entries to store

Definition at line 474 of file cons_linear.c.

References linconsupgradeCreate(), NULL, SCIP_CALL, SCIP_DECL_LINCONSUPGD, SCIP_OKAY, SCIPallocBlockMemory, SCIPreallocBlockMemoryArray, and TRUE.

◆ 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
scipSCIP data structure
linconsupgradepointer to store the linear constraint upgrade
prioritypriority of upgrading method

Definition at line 509 of file cons_linear.c.

References conshdlrdataCreate(), NULL, and SCIPfreeBlockMemory.

Referenced by consdataEnsureVarsSize().

◆ linconsupgradeFree()

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

frees a linear constraint upgrade data object

Parameters
scipSCIP data structure
linconsupgradepointer to the linear constraint upgrade

Definition at line 530 of file cons_linear.c.

References NULL, SCIP_CALL, and SCIPallocBlockMemory.

Referenced by conshdlrdataCreate().

◆ conshdlrdataCreate()

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

creates constraint handler data for linear constraint handler

Parameters
scipSCIP data structure
conshdlrdatapointer to store the constraint handler data
eventhdlrevent handler

Definition at line 544 of file cons_linear.c.

References linconsupgradeFree(), NULL, and SCIPfreeBlockMemoryArrayNull.

Referenced by linconsupgradeCreate().

◆ conshdlrdataFree()

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

frees constraint handler data for linear constraint handler

Parameters
scipSCIP data structure
conshdlrdatapointer to the constraint handler data

Definition at line 568 of file cons_linear.c.

Referenced by SCIP_DECL_CONSHDLRCOPY().

◆ 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
scipSCIP data structure
conshdlrdataconstraint handler data
conshdlrnamename of the constraint handler

Definition at line 590 of file cons_linear.c.

References conshdlrdataEnsureLinconsupgradesSize(), conshdlrdataIncludeUpgrade(), FALSE, NULL, SCIP_LinConsUpgrade::priority, SCIP_CALL, SCIPwarningMessage(), and TRUE.

◆ 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
scipSCIP data structure
conshdlrdataconstraint handler data
linconsupgradelinear constraint upgrade method

Definition at line 620 of file cons_linear.c.

Referenced by conshdlrdataHasUpgrade().

◆ 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
scipSCIP data structure
conslinear constraint
varvariable of constraint entry
valcoefficient of constraint entry

Definition at line 652 of file cons_linear.c.

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

◆ 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
scipSCIP data structure
conslinear constraint
varvariable of constraint entry
valcoefficient of constraint entry

Definition at line 685 of file cons_linear.c.

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

Referenced by lockRounding().

◆ 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
scipSCIP data structure
conslinear constraint
eventhdlrevent handler to call for the event processing
posarray position of variable to catch bound change events for

Definition at line 719 of file cons_linear.c.

Referenced by unlockRounding().

◆ 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
scipSCIP data structure
conslinear constraint
eventhdlrevent handler to call for the event processing
posarray position of variable to catch bound change events for

Definition at line 758 of file cons_linear.c.

Referenced by consDropAllEvents().

◆ 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
scipSCIP data structure
conslinear constraint
eventhdlrevent handler to call for the event processing

Definition at line 792 of file cons_linear.c.

◆ 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
scipSCIP data structure
conslinear constraint
eventhdlrevent handler to call for the event processing

Definition at line 824 of file cons_linear.c.

References consdataCreate(), consDropEvent(), NULL, SCIP_CALL, SCIP_OKAY, SCIP_Real, and SCIPfreeBlockMemoryArray.

◆ 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
scipSCIP data structure
consdatapointer to linear constraint data
nvarsnumber of nonzeros in the constraint
varsarray with variables of constraint entries
valsarray with coefficients of constraint entries
lhsleft hand side of row
rhsright hand side of row

Definition at line 855 of file cons_linear.c.

Referenced by consDropAllEvents(), and SCIPcreateConsLinear().

◆ consdataFree()

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

frees a linear constraint data

Parameters
scipSCIP data structure
consdatapointer to linear constraint data

Definition at line 1054 of file cons_linear.c.

References consdataPrint(), NULL, SCIP_CALL, SCIP_OKAY, SCIPfreeBlockMemory, SCIPfreeBlockMemoryArrayNull, SCIPinfoMessage(), SCIPisEQ(), SCIPisInfinity(), SCIPisZero(), and SCIPreleaseVar().

◆ consdataPrint()

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

prints linear constraint in CIP format to file stream

Parameters
scipSCIP data structure
consdatalinear constraint data
fileoutput file (or NULL for standard output)

Definition at line 1089 of file cons_linear.c.

Referenced by consdataFree(), and SCIP_DECL_CONSDELVARS().

◆ 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
scipSCIP data structure
conslinear constraint
solsolution to print
fileoutput file (or NULL for standard output)

Definition at line 1128 of file cons_linear.c.

Referenced by SCIP_DECL_CONSCHECK().

◆ consdataInvalidateActivities()

static void consdataInvalidateActivities ( SCIP_CONSDATA consdata)
static

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

Parameters
consdatalinear constraint

Definition at line 1200 of file cons_linear.c.

References bound, and SCIP_Real.

◆ consdataComputePseudoActivity()

static SCIP_Real consdataComputePseudoActivity ( SCIP scip,
SCIP_CONSDATA consdata 
)
static

compute the pseudo activity of a constraint

Parameters
scipSCIP data structure
consdatalinear constraint data

Definition at line 1246 of file cons_linear.c.

References bound, consdataRecomputeMinactivity(), SCIP_BOUNDTYPE_LOWER, SCIP_INVALID, SCIP_Real, SCIPinfinity(), SCIPisHugeValue(), SCIPisInfinity(), SCIPvarGetBestBoundType(), SCIPvarGetLbLocal(), and SCIPvarGetUbLocal().

Referenced by consdataGetGlbActivityResiduals().

◆ consdataRecomputeMinactivity()

static void consdataRecomputeMinactivity ( SCIP scip,
SCIP_CONSDATA consdata 
)
static

recompute the minactivity of a constraint

Parameters
scipSCIP data structure
consdatalinear constraint data

Definition at line 1299 of file cons_linear.c.

References bound, SCIP_Real, SCIPisHugeValue(), SCIPisInfinity(), SCIPvarGetLbLocal(), and SCIPvarGetUbLocal().

Referenced by consdataComputePseudoActivity().

◆ consdataRecomputeMaxactivity()

static void consdataRecomputeMaxactivity ( SCIP scip,
SCIP_CONSDATA consdata 
)
static

recompute the maxactivity of a constraint

Parameters
scipSCIP data structure
consdatalinear constraint data

Definition at line 1326 of file cons_linear.c.

References bound, SCIP_Real, SCIPisHugeValue(), SCIPisInfinity(), SCIPvarGetLbGlobal(), and SCIPvarGetUbGlobal().

◆ consdataRecomputeGlbMinactivity()

static void consdataRecomputeGlbMinactivity ( SCIP scip,
SCIP_CONSDATA consdata 
)
static

recompute the global minactivity of a constraint

Parameters
scipSCIP data structure
consdatalinear constraint data

Definition at line 1353 of file cons_linear.c.

References bound, SCIP_Real, SCIPisHugeValue(), SCIPisInfinity(), SCIPvarGetLbGlobal(), and SCIPvarGetUbGlobal().

◆ consdataRecomputeGlbMaxactivity()

static void consdataRecomputeGlbMaxactivity ( SCIP scip,
SCIP_CONSDATA consdata 
)
static

recompute the global maxactivity of a constraint

Parameters
scipSCIP data structure
consdatalinear constraint data

Definition at line 1380 of file cons_linear.c.

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

◆ consdataCalcMaxAbsval()

static void consdataCalcMaxAbsval ( SCIP_CONSDATA consdata)
static

calculates maximum absolute value of coefficients

Parameters
consdatalinear constraint data

Definition at line 1407 of file cons_linear.c.

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

◆ consdataCalcMinAbsval()

static void consdataCalcMinAbsval ( SCIP_CONSDATA consdata)
static

calculates minimum absolute value of coefficients

Parameters
consdatalinear constraint data

Definition at line 1431 of file cons_linear.c.

References consdataCheckNonbinvar(), FALSE, REALABS, SCIP_VARTYPE_BINARY, SCIPvarGetType(), and TRUE.

Referenced by consdataGetMaxAbsval().

◆ 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
consdatalinear constraint data

Definition at line 1460 of file cons_linear.c.

References checkMaxActivityDelta, consdataRecomputeMaxActivityDelta(), REALABS, SCIP_INVALID, SCIP_Real, SCIPinfinity(), SCIPisFeasEQ(), SCIPisInfinity(), SCIPvarGetLbLocal(), SCIPvarGetUbLocal(), and TRUE.

Referenced by consdataCalcMinAbsval().

◆ consdataRecomputeMaxActivityDelta()

static void consdataRecomputeMaxActivityDelta ( SCIP scip,
SCIP_CONSDATA consdata 
)
static

recompute maximal activity contribution for a single variable

Parameters
scipSCIP data structure
consdatalinear constraint data

Definition at line 1536 of file cons_linear.c.

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

Referenced by consdataCheckNonbinvar().

◆ 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
scipSCIP data structure
consdatalinear constraint data
varvariable that has been changed; can be NULL for global bound changes
oldboundold bound of variable
newboundnew bound of variable
valcoefficient of constraint entry
boundtypetype of the bound change
globalis it a global or a local bound change?
checkreliabilityshould the reliability of the recalculated activity be checked?

Definition at line 1598 of file cons_linear.c.

Referenced by consdataRecomputeMaxActivityDelta().

◆ 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
scipSCIP data structure
consdatalinear constraint data
varvariable that has been changed
oldlbold lower bound of variable
newlbnew lower bound of variable
valcoefficient of constraint entry
checkreliabilityshould the reliability of the recalculated activity be checked?

Definition at line 1983 of file cons_linear.c.

◆ 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
scipSCIP data structure
consdatalinear constraint data
varvariable that has been changed
oldubold upper bound of variable
newubnew upper bound of variable
valcoefficient of constraint entry
checkreliabilityshould the reliability of the recalculated activity be checked?

Definition at line 2008 of file cons_linear.c.

◆ 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
scipSCIP data structure
consdatalinear constraint data
oldlbold lower bound of variable
newlbnew lower bound of variable
valcoefficient of constraint entry
checkreliabilityshould the reliability of the recalculated activity be checked?

Definition at line 2033 of file cons_linear.c.

◆ 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
scipSCIP data structure
consdatalinear constraint data
oldubold upper bound of variable
newubnew upper bound of variable
valcoefficient of constraint entry
checkreliabilityshould the reliability of the recalculated activity be checked?

Definition at line 2056 of file cons_linear.c.

◆ 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
scipSCIP data structure
consdatalinear constraint data
varvariable of constraint entry
valcoefficient of constraint entry
checkreliabilityshould the reliability of the recalculated activity be checked?

Definition at line 2079 of file cons_linear.c.

◆ 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
scipSCIP data structure
consdatalinear constraint data
varvariable of constraint entry
valcoefficient of constraint entry
checkreliabilityshould the reliability of the recalculated activity be checked?

Definition at line 2129 of file cons_linear.c.

◆ 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
scipSCIP data structure
consdatalinear constraint data
varvariable of constraint entry
oldvalold coefficient of constraint entry
newvalnew coefficient of constraint entry
checkreliabilityshould the reliability of the recalculated activity be checked?

Definition at line 2186 of file cons_linear.c.

◆ consdataGetMaxAbsval()

static SCIP_Real consdataGetMaxAbsval ( SCIP_CONSDATA consdata)
static

returns the maximum absolute value of all coefficients in the constraint

Parameters
consdatalinear constraint data

Definition at line 2285 of file cons_linear.c.

References consdataCalcMinAbsval(), NULL, and SCIP_INVALID.

Referenced by aggregateConstraints().

◆ consdataGetMinAbsval()

static SCIP_Real consdataGetMinAbsval ( SCIP_CONSDATA consdata)
static

returns the minimum absolute value of all coefficients in the constraint

Parameters
consdatalinear constraint data

Definition at line 2301 of file cons_linear.c.

References NULL, SCIP_INVALID, and TRUE.

◆ 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
scipSCIP data structure
consdatalinear constraint data

Definition at line 2319 of file cons_linear.c.

Referenced by consdataGetActivityResiduals(), and consdataGetGlbActivityResiduals().

◆ 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 isrelax,
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
scipSCIP data structure
consdatalinear constraint
posinfnumber of coefficients contributing pos. infinite value
neginfnumber of coefficients contributing neg. infinite value
poshugenumber of coefficients contributing huge pos. value
neghugenumber of coefficients contributing huge neg. value
deltavalue to subtract from stored minactivity (contribution of the variable set to zero when getting residual activity)
globalshould the global or local minimal activity be returned?
goodrelaxshould a good relaxation be computed or are relaxed acticities ignored, anyway?
minactivitypointer to store the minimal activity
isrelaxpointer to store whether the activity is a relaxation, i.e. is <= the exact minactivity (in case of huge contributing values)
issettoinfinitypointer to store whether minactivity was set to infinity or calculated

Definition at line 2381 of file cons_linear.c.

Referenced by consdataGetActivityResiduals(), 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 isrelax,
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
scipSCIP data structure
consdatalinear constraint
posinfnumber of coefficients contributing pos. infinite value
neginfnumber of coefficients contributing neg. infinite value
poshugenumber of coefficients contributing huge pos. value
neghugenumber of coefficients contributing huge neg. value
deltavalue to subtract from stored maxactivity (contribution of the variable set to zero when getting residual activity)
globalshould the global or local maximal activity be returned?
goodrelaxshould a good relaxation be computed or are relaxed acticities ignored, anyway?
maxactivitypointer to store the maximal activity
isrelaxpointer to store whether the activity is a relaxation, i.e. is >= the exact maxactivity (in case of huge contributing values)
issettoinfinitypointer to store whether maxactivity was set to infinity or calculated

Definition at line 2482 of file cons_linear.c.

Referenced by consdataGetActivityResiduals(), and consdataGetGlbActivityResiduals().

◆ consdataGetActivityBounds()

static void consdataGetActivityBounds ( SCIP scip,
SCIP_CONSDATA consdata,
SCIP_Bool  goodrelax,
SCIP_Real minactivity,
SCIP_Real maxactivity,
SCIP_Bool minisrelax,
SCIP_Bool maxisrelax 
)
static

gets activity bounds for constraint

Parameters
scipSCIP data structure
consdatalinear constraint
goodrelaxif we have huge contributions, do we need a good relaxation or are relaxed acticities ignored, anyway?
minactivitypointer to store the minimal activity
maxactivitypointer to store the maximal activity
minisrelaxpointer to store whether the returned minactivity is just a relaxation, i.e. <= the exact minactivity (in case of huge contributions), or equal to the exact minimal activity
maxisrelaxpointer to store whether the returned maxactivity is just a relaxation, i.e. >= the exact maxactivity (in case of huge contributions), or equal to the exact maximal activity

Definition at line 2581 of file cons_linear.c.

◆ 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
scipSCIP data structure
consdatalinear constraint
cancelvarvariable to calculate activity residual for
resactivitypointer to store the residual activity
isminresactshould minimal or maximal residual activity be calculated?
useglobalboundsshould global or local bounds be used?

Definition at line 2627 of file cons_linear.c.

◆ 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 minisrelax,
SCIP_Bool maxisrelax,
SCIP_Bool isminsettoinfinity,
SCIP_Bool ismaxsettoinfinity 
)
static

gets activity bounds for constraint after setting variable to zero

Parameters
scipSCIP data structure
consdatalinear constraint
varvariable to calculate activity residual for
valcoefficient value of variable in linear constraint
goodrelaxif we have huge contributions, do we need a good relaxation or are relaxed acticities ignored, anyway?
minresactivitypointer to store the minimal residual activity
maxresactivitypointer to store the maximal residual activity
minisrelaxpointer to store whether the returned residual minactivity is just a relaxation, i.e. <= the exact residual minactivity (in case of huge contributions), or equal to the exact residual minactivity
maxisrelaxpointer to store whether the returned residual maxactivity is just a relaxation, i.e. <= the exact residual maxactivity (in case of huge contributions), or equal to the exact residual minactivity
isminsettoinfinitypointer to store whether minresactivity was set to infinity or calculated
ismaxsettoinfinitypointer to store whether maxresactivity was set to infinity or calculated

Definition at line 2708 of file cons_linear.c.

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

◆ consdataGetGlbActivityBounds()

static void consdataGetGlbActivityBounds ( SCIP scip,
SCIP_CONSDATA consdata,
SCIP_Bool  goodrelax,
SCIP_Real glbminactivity,
SCIP_Real glbmaxactivity,
SCIP_Bool minisrelax,
SCIP_Bool maxisrelax,
SCIP_Bool isminsettoinfinity,
SCIP_Bool ismaxsettoinfinity 
)
static

gets global activity bounds for constraint

Parameters
scipSCIP data structure
consdatalinear constraint
goodrelaxif we have huge contributions, do we need a good relaxation or are relaxed acticities ignored, anyway?
glbminactivitypointer to store the minimal activity, or NULL, if not needed
glbmaxactivitypointer to store the maximal activity, or NULL, if not needed
minisrelaxpointer to store whether the returned minactivity is just a relaxation, i.e. <= the exact minactivity (in case of huge contributions), or equal to the exact minimal activity
maxisrelaxpointer to store whether the returned maxactivity is just a relaxation, i.e. >= the exact maxactivity (in case of huge contributions), or equal to the exact maximal activity
isminsettoinfinitypointer to store whether minresactivity was set to infinity or calculated
ismaxsettoinfinitypointer to store whether maxresactivity was set to infinity or calculated

Definition at line 2859 of file cons_linear.c.

Referenced by consdataGetActivityResiduals().

◆ 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 minisrelax,
SCIP_Bool maxisrelax,
SCIP_Bool isminsettoinfinity,
SCIP_Bool ismaxsettoinfinity 
)
static

gets global activity bounds for constraint after setting variable to zero

Parameters
scipSCIP data structure
consdatalinear constraint
varvariable to calculate activity residual for
valcoefficient value of variable in linear constraint
goodrelaxif we have huge contributions, do we need a good relaxation or are relaxed acticities ignored, anyway?
minresactivitypointer to store the minimal residual activity, or NULL, if not needed
maxresactivitypointer to store the maximal residual activity, or NULL, if not needed
minisrelaxpointer to store whether the returned residual minactivity is just a relaxation, i.e. <= the exact residual minactivity (in case of huge contributions), or equal to the exact residual minactivity
maxisrelaxpointer to store whether the returned residual maxactivity is just a relaxation, i.e. <= the exact residual maxactivity (in case of huge contributions), or equal to the exact residual minactivity
isminsettoinfinitypointer to store whether minresactivity was set to infinity or calculated
ismaxsettoinfinitypointer to store whether maxresactivity was set to infinity or calculated

Definition at line 2921 of file cons_linear.c.

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

◆ 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
scipSCIP data structure
consdatalinear constraint data
solsolution to get activity for, NULL to current solution

Definition at line 3073 of file cons_linear.c.

References consdataGetFeasibility(), FALSE, MAX, MIN, NULL, SCIP_INVALID, SCIP_Real, SCIPdebugMsg, SCIPgetSolVal(), SCIPinfinity(), SCIPisInfinity(), and TRUE.

Referenced by consdataGetGlbActivityResiduals(), and SCIP_DECL_CONSCHECK().

◆ 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
scipSCIP data structure
consdatalinear constraint data
solsolution to get feasibility for, NULL to current solution

Definition at line 3141 of file cons_linear.c.

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

Referenced by consdataGetActivity().

◆ consdataUpdateSignatures()

static void consdataUpdateSignatures ( SCIP_CONSDATA consdata,
int  pos 
)
static

updates bit signatures after adding a single coefficient

Parameters
consdatalinear constraint data
posposition of coefficient to update signatures for

Definition at line 3162 of file cons_linear.c.

References NULL, and TRUE.

◆ consdataCalcSignatures()

static void consdataCalcSignatures ( SCIP_CONSDATA consdata)
static

calculates the bit signatures of the given constraint data

Parameters
consdatalinear constraint data

Definition at line 3187 of file cons_linear.c.

References NULL, permSortConsdata(), and SCIPvarCompare().

◆ SCIP_DECL_SORTINDCOMP() [1/2]

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 3207 of file cons_linear.c.

References NULL, and SCIP_Real.

Referenced by aggregateVariables().

◆ permSortConsdata()

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

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

Parameters
consdatathe constraint data
permthe target permutation
nvarsthe number of variables

Definition at line 3220 of file cons_linear.c.

References consdataSort(), NULL, SCIP_STAGE_INITSOLVE, SCIPgetStage(), and TRUE.

Referenced by consdataCalcSignatures().

◆ 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 binaries, integers, implicit integers, and continuous variables, and the variables of the same type by non-decreasing variable index
  • during SOLVING sorts binary variables of the remaining problem w.r.t the absolute of their coefficient. This fastens the propagation time of the constraint handler.
Parameters
scipSCIP data structure
consdatalinear constraint data

Definition at line 3293 of file cons_linear.c.

Referenced by permSortConsdata().

◆ chgLhs()

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

sets left hand side of linear constraint

Parameters
scipSCIP data structure
conslinear constraint
lhsnew left hand side

Definition at line 3441 of file cons_linear.c.

Referenced by SCIPaddCoefLinear().

◆ chgRhs()

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

sets right hand side of linear constraint

Parameters
scipSCIP data structure
conslinear constraint
rhsnew right hand side

Definition at line 3567 of file cons_linear.c.

Referenced by SCIPaddCoefLinear(), and SCIPchgLhsLinear().

◆ addCoef()

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

adds coefficient in linear constraint

Parameters
scipSCIP data structure
conslinear constraint
varvariable of constraint entry
valcoefficient of constraint entry

Definition at line 3695 of file cons_linear.c.

Referenced by SCIPaddCoefLinear().

◆ delCoefPos()

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

deletes coefficient at given position from linear constraint data

Parameters
scipSCIP data structure
conslinear constraint
posposition of coefficient to delete

Definition at line 3849 of file cons_linear.c.

Referenced by performVarDeletions(), and SCIPchgCoefLinear().

◆ 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
scipSCIP data structure
conslinear constraint
posposition of coefficient to delete
newvalnew value of coefficient

Definition at line 3970 of file cons_linear.c.

Referenced by SCIPchgCoefLinear().

◆ scaleCons()

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

scales a linear constraint with a constant scalar

Parameters
scipSCIP data structure
conslinear constraint to scale
scalarvalue to scale constraint with

Definition at line 4043 of file cons_linear.c.

◆ performVarDeletions()

static SCIP_RETCODE performVarDeletions ( SCIP scip,
SCIP_CONSHDLR conshdlr,
SCIP_CONS **  conss,
int  nconss 
)
static
Parameters
scipSCIP data structure
conshdlrconstraint handler
conssarray of constraints
nconssnumber of constraints

Definition at line 4127 of file cons_linear.c.

References delCoefPos(), FALSE, normalizeCons(), SCIP_Bool, SCIP_CALL, SCIP_Longint, SCIP_OKAY, SCIP_Real, SCIPconsGetData(), and SCIPvarIsDeleted().

Referenced by SCIP_DECL_CONSLOCK().

◆ 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
scipSCIP data structure
conslinear constraint to normalize
infeasiblepointer to store whether infeasibility was detected

Definition at line 4186 of file cons_linear.c.

Referenced by aggregateConstraints(), aggregateVariables(), and performVarDeletions().

◆ mergeMultiples()

static SCIP_RETCODE mergeMultiples ( SCIP scip,
SCIP_CONS cons 
)
static

replaces multiple occurrences of a variable by a single coefficient

Parameters
scipSCIP data structure
conslinear constraint

Definition at line 4518 of file cons_linear.c.

◆ 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
scipSCIP data structure
conslinear constraint
infeasiblepointer 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 4589 of file cons_linear.c.

Referenced by aggregateVariables().

◆ 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
scipSCIP data structure
consconstraint that inferred the bound change
infervarvariable that was deduced, or NULL
bdchgidxbound change index (time stamp of bound change), or NULL for current time
inferposposition of the inferred variable in the vars array
reasonisrhsis the right hand side responsible for the bound change?

Definition at line 4832 of file cons_linear.c.

◆ 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
scipSCIP data structure
consconstraint that inferred the bound change
infervarvariable that was deduced, or NULL
bdchgidxbound change index (time stamp of bound change), or NULL for current time
inferposposition of the inferred variable in the vars array, or -1

Definition at line 5014 of file cons_linear.c.

◆ 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
scipSCIP data structure
varsvariables reasoning the infeasibility
nvarsnumber of variables reasoning the infeasibility
varvariable which was tried to fix/tighten, or NULL
boundbound of variable which was tried to apply, or SCIP_INVALID

Definition at line 5079 of file cons_linear.c.

References NULL, resolvePropagation(), SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPisEQ(), SCIPvarGetLbLocal(), SCIPvarGetUbGlobal(), and SCIPvarGetUbLocal().

◆ 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
scipSCIP data structure
consconstraint that inferred the bound change
infervarvariable that was deduced
inferinfoinference information
boundtypethe type of the changed bound (lower or upper bound)
bdchgidxbound change index (time stamp of bound change), or NULL for current time
resultpointer to store the result of the propagation conflict resolving call

Definition at line 5130 of file cons_linear.c.

Referenced by addConflictReasonVars().

◆ 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
scipSCIP data structure
consconflict detecting constraint
reasonisrhsis the right hand side responsible for the conflict?

Definition at line 5223 of file cons_linear.c.

◆ canTightenBounds()

static SCIP_Bool canTightenBounds ( SCIP scip,
SCIP_CONS cons 
)
static

check if there is any hope of tightening some bounds

Parameters
scipSCIP data structure
conslinear constraint

Definition at line 5247 of file cons_linear.c.

References SCIP_Bool, and SCIP_Real.

◆ 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
scipSCIP data structure
conslinear constraint
posvariable position
proprulepropagation rule that deduced the value
newubnew upper bound
oldubold upper bound
cutoffpointer to store whether the node can be cut off
nchgbdspointer to count the total number of tightened bounds
forceshould a possible bound change be forced even if below bound strengthening tolerance

Definition at line 5276 of file cons_linear.c.

◆ 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
scipSCIP data structure
conslinear constraint
posvariable position
proprulepropagation rule that deduced the value
newlbnew lower bound
oldlbold lower bound
cutoffpointer to store whether the node can be cut off
nchgbdspointer to count the total number of tightened bounds
forceshould a possible bound change be forced even if below bound strengthening tolerance

Definition at line 5345 of file cons_linear.c.

◆ 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
scipSCIP data structure
conslinear constraint
posposition of the variable in the vars array
cutoffpointer to store whether the node can be cut off
nchgbdspointer to count the total number of tightened bounds
forceshould a possible bound change be forced even if below bound strengthening tolerance

Definition at line 5414 of file cons_linear.c.

◆ 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
scipSCIP data structure
consconflict detecting constraint
varsvariables reasoning the infeasibility
nvarsnumber of variables reasoning the infeasibility
varvariable which was tried to fix/tighten, or NULL
boundbound of variable which was tried to apply, or SCIP_INVALID

Definition at line 5674 of file cons_linear.c.

◆ 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
scipSCIP data structure
conslinear constraint
cutoffpointer to store TRUE, if a cutoff was found
nfixedvarspointer to count number of fixed variables
nchgbdspointer to count the number of bound changes
naddconsspointer to count number of added constraints

Definition at line 5732 of file cons_linear.c.

◆ 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
scipSCIP data structure
conslinear constraint
posposition of the variable in the vars array
cutoffpointer to store whether the node can be cut off
nchgbdspointer to count the total number of tightened bounds
forceshould a possible bound change be forced even if below bound strengthening tolerance

Definition at line 6705 of file cons_linear.c.

◆ 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
scipSCIP data structure
conslinear constraint
maxeasyactivitydeltamaximum activity delta to run easy propagation on linear constraint
sortvarsshould variables be used in sorted order?
cutoffpointer to store whether the node can be cut off
nchgbdspointer to count the total number of tightened bounds

Definition at line 6977 of file cons_linear.c.

◆ 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
scipSCIP data structure
conslinear constraint
solsolution to be checked, or NULL for current solution
checklprowsDo constraints represented by rows in the current LP have to be checked?
checkrelmaxabsShould 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)?
violatedpointer to store whether the constraint is violated

Definition at line 7144 of file cons_linear.c.

Referenced by SCIP_DECL_CONSCHECK().

◆ createRow()

static SCIP_RETCODE createRow ( SCIP scip,
SCIP_CONS cons 
)
static

creates an LP row in a linear constraint data

Parameters
scipSCIP data structure
conslinear constraint

Definition at line 7404 of file cons_linear.c.

◆ addRelaxation()

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

adds linear constraint as cut to the LP

Parameters
scipSCIP data structure
conslinear constraint
cutoffpointer to store whether a cutoff was found

Definition at line 7428 of file cons_linear.c.

◆ 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
scipSCIP data structure
conslinear constraint
conshdlrdataconstraint handler data
solprimal CIP solution, NULL for current LP solution
separatecardsshould knapsack cardinality cuts be generated?
separateallshould all constraints be subject to cardinality cut generation instead of only the ones with non-zero dual value?
ncutspointer to add up the number of found cuts
cutoffpointer to store whether a cutoff was found

Definition at line 7481 of file cons_linear.c.

◆ 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
scipSCIP data structure
conslinear constraint
tightenboundsshould the variable's bounds be tightened?
rangedrowpropagationshould ranged row propagation be performed?
maxeasyactivitydeltamaximum activity delta to run easy propagation on linear constraint
sortvarsshould variable sorting for faster propagation be used?
cutoffpointer to store whether the node can be cut off
nchgbdspointer to count the total number of tightened bounds

Definition at line 7571 of file cons_linear.c.

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
scipSCIP data structure
conslinear constraint
cutoffpointer to store TRUE, if a cutoff was found
nfixedvarspointer to count the total number of fixed variables

Definition at line 7718 of file cons_linear.c.

◆ 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
scipSCIP data structure
conslinear constraint
maxeasyactivitydeltamaximum activity delta to run easy propagation on linear constraint
sortvarsshould variables be used in sorted order?
nfixedvarspointer to count number of fixed variables
nchgbdspointer to count the total number of tightened bounds
cutoffpointer to store TRUE, if a cutoff was found

Definition at line 7853 of file cons_linear.c.

◆ 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
scipSCIP data structure
conslinear constraint
nchgsidespointer to count number of side changes
infeasiblepointer to store whether infeasibility was detected

Definition at line 8819 of file cons_linear.c.

◆ consdataTightenCoefs()

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

tightens coefficients of binary, integer, and implicit integer 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) 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) lhs' := lhs - (ai - ai')*ui rhs' := rhs - (ai - ai')*li

We further try to remove redundant variable from the constraint; Variables which fulfill conditions (**) or (***) are called surely non-redundant 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 surely non-redundant 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
scipSCIP data structure
conslinear constraint
nchgcoefspointer to count total number of changed coefficients
nchgsidespointer to count number of side changes

Definition at line 8940 of file cons_linear.c.

◆ convertUnaryEquality()

static SCIP_RETCODE convertUnaryEquality ( SCIP scip,
SCIP_CONS cons,
SCIP_Bool cutoff,
int *  nfixedvars,
int *  ndelconss 
)
static
Parameters
scipSCIP data structure
conslinear constraint
cutoffpointer to store TRUE, if a cutoff was found
nfixedvarspointer to count number of fixed variables
ndelconsspointer to count number of deleted constraints

Definition at line 9367 of file cons_linear.c.

◆ convertBinaryEquality()

static SCIP_RETCODE convertBinaryEquality ( SCIP scip,
SCIP_CONS cons,
SCIP_Bool cutoff,
int *  naggrvars,
int *  ndelconss 
)
static
Parameters
scipSCIP data structure
conslinear constraint
cutoffpointer to store TRUE, if a cutoff was found
naggrvarspointer to count number of aggregated variables
ndelconsspointer to count number of deleted constraints

Definition at line 9423 of file cons_linear.c.

◆ 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
scipSCIP data structure
consdatalinear constraint data
slackvarvariable to be aggregated out
slackcoefcoefficient of variable in constraint
newlhspointer to store new lhs of constraint
newrhspointer to store new rhs of constraint

Definition at line 9481 of file cons_linear.c.

◆ convertLongEquality()

static SCIP_RETCODE convertLongEquality ( SCIP scip,
SCIP_CONSHDLRDATA conshdlrdata,
SCIP_CONS cons,
SCIP_Bool cutoff,
int *  naggrvars,
int *  ndelconss 
)
static
Parameters
scipSCIP data structure
conshdlrdatalinear constraint handler data
conslinear constraint
cutoffpointer to store TRUE, if a cutoff was found
naggrvarspointer to count number of aggregated variables
ndelconsspointer to count number of deleted constraints

Definition at line 9537 of file cons_linear.c.

◆ 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
scipSCIP data structure
consdatalinear constraint data
scalepointer to store the scaling factor between the constraint and the objective function
offsetpointer to store the offset of the objective function resulting by this constraint

Definition at line 10078 of file cons_linear.c.

◆ 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
scipSCIP data structure
conslinear equation constraint
conshdlrdatalinear constraint handler data

Definition at line 10156 of file cons_linear.c.

◆ 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
scipSCIP data structure
consconstraint
primalboundfeasible primal bound

Definition at line 10223 of file cons_linear.c.

◆ 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
scipSCIP data structure
conslinear constraint
conshdlrdatalinear constraint handler data

Definition at line 10269 of file cons_linear.c.

◆ convertEquality()

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

converts special equalities

Parameters
scipSCIP data structure
conslinear constraint
conshdlrdatalinear constraint handler data
cutoffpointer to store TRUE, if a cutoff was found
nfixedvarspointer to count number of fixed variables
naggrvarspointer to count number of aggregated variables
ndelconsspointer to count number of deleted constraints

Definition at line 10394 of file cons_linear.c.

◆ 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
scipSCIP data structure
consdatalinear constraint
posposition of variable to be left out
valvalue to divide the coefficients by

Definition at line 10449 of file cons_linear.c.

References ABS, NULL, and SCIPisInfinity().

◆ 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
Parameters
scipSCIP data structure
sidelhs or rhs
valcoefficient
minresactivityminimal residual activity
maxresactivitymaximal residual activity
minvalpointer to store calculated minval
maxvalpointer to store calculated maxval

Definition at line 10475 of file cons_linear.c.

References ABS, dualPresolve(), SCIP_Bool, and SCIPisInfinity().

◆ dualPresolve()

static SCIP_RETCODE dualPresolve ( SCIP scip,
SCIP_CONS cons,
SCIP_Bool cutoff,
int *  nfixedvars,
int *  naggrvars,
int *  ndelconss 
)
static
Parameters
scipSCIP data structure
conslinear constraint
cutoffpointer to store TRUE, if a cutoff was found
nfixedvarspointer to count number of fixed variables
naggrvarspointer to count number of aggregated variables
ndelconsspointer to count number of deleted constraints

Definition at line 10520 of file cons_linear.c.

Referenced by calculateMinvalAndMaxval().

◆ getVarWeight()

static int getVarWeight ( SCIP_VAR var)
static

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

Parameters
varvariable to get weight for

Definition at line 10962 of file cons_linear.c.

References NULL, SCIP_Bool, and SCIPconsGetData().

Referenced by aggregateConstraints().

◆ aggregateVariables()

static SCIP_RETCODE aggregateVariables ( SCIP scip,
SCIP_CONS cons,
SCIP_Bool cutoff,
int *  nfixedvars,
int *  naggrvars,
int *  ndelconss 
)
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
scipSCIP data structure
conslinear constraint
cutoffpointer to store TRUE, if a cutoff was found
nfixedvarspointer to count number of fixed variables
naggrvarspointer to count number of aggregated variables
ndelconsspointer to count number of deleted constraints

Definition at line 10995 of file cons_linear.c.

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

Referenced by checkCons(), and SCIP_DECL_CONSPRESOL().

◆ SCIP_DECL_SORTINDCOMP() [2/2]

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 11168 of file cons_linear.c.

◆ rangedRowSimplify()

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

tries to simplify coefficients and delete variables in ranged row of the form lhs <= a^Tx <= rhs, e.g. using the greatest common divisor

  1. lhs <= a^Tx <= rhs, 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
scipSCIP data structure
conslinear constraint
nchgcoefspointer to store the amount of changed coefficients
nchgsidespointer to store the amount of changed sides

Definition at line 11208 of file cons_linear.c.

◆ 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 equations

See also
rangedRowSimplify() will be called

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
scipSCIP data structure
conslinear constraint
nchgcoefspointer to store the amount of changed coefficients
nchgsidespointer to store the amount of changed sides
infeasiblepointer to store whether infeasibility was detected

Definition at line 11320 of file cons_linear.c.

◆ 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
Parameters
scipSCIP data structure
cons0(in)equality to modify
cons1equality to use for aggregation of cons0
commonidx0array with indices of variables in cons0, that appear also in cons1
commonidx1array with indices of variables in cons1, that appear also in cons0
diffidx0minus1array with indices of variables in cons0, that don't appear in cons1
diffidx1minus0array with indices of variables in cons1, that don't appear in cons0
nvarscommonnumber of variables, that appear in both constraints
commonidxweightvariable weight sum of common variables
diffidx0minus1weightvariable weight sum of variables in cons0, that don't appear in cons1
diffidx1minus0weightvariable weight sum of variables in cons1, that don't appear in cons0
maxaggrnormscalemaximal allowed relative gain in maximum norm for constraint aggregation
nchgcoefspointer to count the number of changed coefficients
aggregatedpointer to store whether an aggregation was made
infeasiblepointer to store whether infeasibility was detected

Definition at line 12543 of file cons_linear.c.

References a, b, consdataGetMaxAbsval(), FALSE, getVarWeight(), normalizeCons(), NULL, REALABS, SCIP_Bool, SCIP_CALL, SCIP_DECL_HASHGETKEY(), SCIP_DECL_HASHKEYEQ(), SCIP_OKAY, SCIP_Real, SCIPaddCons(), 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.

◆ SCIP_DECL_HASHGETKEY()

static SCIP_DECL_HASHGETKEY ( hashGetKeyLinearcons  )
static

gets the key of the given element

Definition at line 12863 of file cons_linear.c.

Referenced by aggregateConstraints().

◆ 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 12873 of file cons_linear.c.

Referenced by aggregateConstraints().

◆ SCIP_DECL_HASHKEYVAL()

static SCIP_DECL_HASHKEYVAL ( hashKeyValLinearcons  )
static

returns the hash value of the key

Definition at line 12934 of file cons_linear.c.

◆ 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
conslinear constraint

Definition at line 12972 of file cons_linear.c.

References NULL, and SCIPhashtableRetrieve().

◆ 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
hashtablehashtable containing linear constraints
queryconspointer to linear constraint used to look for duplicates in the hash table; upon return will contain the constraint that should be kept
parallelconssarray to return constraints that are parallel to the given; these constraints where removed from the hashtable
nparallelconsspointer to return number of parallel constraints

Definition at line 12991 of file cons_linear.c.

◆ 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
scipSCIP data structure
blkmemblock memory
conssconstraint set
nconssnumber of constraints in constraint set
firstchangepointer to store first changed constraint
cutoffpointer to store TRUE, if a cutoff was found
ndelconsspointer to count number of deleted constraints
nchgsidespointer to count number of changed left/right hand sides

Definition at line 13052 of file cons_linear.c.

◆ 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
scipSCIP data structure
conssconstraint set
firstchangefirst constraint that changed since last pair preprocessing round
chkindindex of constraint to check against all prior indices upto startind
maxaggrnormscalemaximal allowed relative gain in maximum norm for constraint aggregation
cutoffpointer to store TRUE, if a cutoff was found
ndelconsspointer to count number of deleted constraints
nchgsidespointer to count number of changed left/right hand sides
nchgcoefspointer to count number of changed coefficients

Definition at line 13246 of file cons_linear.c.

◆ 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
scipSCIP data structure
conslinear constraint
singletonstuffingshould stuffing of singleton continuous variables be performed?
singlevarstuffingshould single variable stuffing be performed, which tries to fulfill constraints using the cheapest variable?
cutoffpointer to store TRUE, if a cutoff was found
nfixedvarspointer to count the total number of fixed variables
nchgbdspointer to count the total number of tightened bounds

Definition at line 13850 of file cons_linear.c.

◆ fullDualPresolve()

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

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

Parameters
scipSCIP data structure
conssconstraint set
nconssnumber of constraints
cutoffpointer to store TRUE, if a cutoff was found
nchgbdspointer to count the number of bound changes

Definition at line 14440 of file cons_linear.c.

◆ 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
scipSCIP data structure
conshdlrconstraint handler
conssconstraints to process
nconssnumber of constraints
nusefulconssnumber of useful (non-obsolete) constraints to process
solsolution to enforce (NULL for the LP solution)
resultpointer to store the result of the enforcing call

Definition at line 14903 of file cons_linear.c.

◆ SCIP_DECL_CONSHDLRCOPY()

static SCIP_DECL_CONSHDLRCOPY ( conshdlrCopyLinear  )
static

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

Definition at line 14979 of file cons_linear.c.

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

◆ 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 14995 of file cons_linear.c.

References NULL, and SCIPconshdlrGetData().

◆ SCIP_DECL_CONSINIT()

static SCIP_DECL_CONSINIT ( consInitLinear  )
static

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

Definition at line 15017 of file cons_linear.c.

◆ SCIP_DECL_CONSEXIT()

static SCIP_DECL_CONSEXIT ( consExitLinear  )
static

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

Definition at line 15043 of file cons_linear.c.

◆ 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
scipSCIP data structure
lhsleft hand side
rhsright hand side

Definition at line 15076 of file cons_linear.c.

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

◆ isFiniteNonnegativeIntegral()

static SCIP_Bool isFiniteNonnegativeIntegral ( SCIP scip,
SCIP_Real  x 
)
static

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

Parameters
scipSCIP data structure
xvalue

Definition at line 15089 of file cons_linear.c.

References CONSHDLR_NAME, NULL, SCIP_STAGE_PROBLEM, SCIPfindConshdlr(), and SCIPgetStage().

◆ SCIP_DECL_CONSEXITPRE()

static SCIP_DECL_CONSEXITPRE ( consExitpreLinear  )
static

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

Definition at line 15447 of file cons_linear.c.

◆ 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 15525 of file cons_linear.c.

References CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_DECL_CONSDEACTIVE(), SCIP_OKAY, SCIP_VERBLEVEL_HIGH, SCIPconsGetData(), SCIPconshdlrGetName(), SCIPconsIsDeleted(), SCIPconvertCutsToConss(), SCIPverbMessage(), and TRUE.

◆ SCIP_DECL_CONSDEACTIVE()

static SCIP_DECL_CONSDEACTIVE ( consDeactiveLinear  )
static

constraint deactivation notification method of constraint handler

Definition at line 15572 of file cons_linear.c.

Referenced by SCIP_DECL_CONSEXITSOL().

◆ SCIP_DECL_CONSDELETE()

static SCIP_DECL_CONSDELETE ( consDeleteLinear  )
static

frees specific constraint data

Definition at line 15609 of file cons_linear.c.

◆ SCIP_DECL_CONSTRANS()

static SCIP_DECL_CONSTRANS ( consTransLinear  )
static

transforms constraint data into data belonging to the transformed problem

Definition at line 15636 of file cons_linear.c.

◆ 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 15670 of file cons_linear.c.

References NULL, SCIP_Bool, and SCIP_Real.

◆ SCIP_DECL_CONSSEPALP()

static SCIP_DECL_CONSSEPALP ( consSepalpLinear  )
static

separation method of constraint handler for LP solutions

Definition at line 15691 of file cons_linear.c.

◆ SCIP_DECL_CONSSEPASOL()

static SCIP_DECL_CONSSEPASOL ( consSepasolLinear  )
static

separation method of constraint handler for arbitrary primal solutions

Definition at line 15762 of file cons_linear.c.

◆ SCIP_DECL_CONSENFOLP()

static SCIP_DECL_CONSENFOLP ( consEnfolpLinear  )
static

constraint enforcing method of constraint handler for LP solutions

Definition at line 15820 of file cons_linear.c.

References NULL, and SCIP_Bool.

◆ SCIP_DECL_CONSENFORELAX()

static SCIP_DECL_CONSENFORELAX ( consEnforelaxLinear  )
static

constraint enforcing method of constraint handler for relaxation solutions

Definition at line 15829 of file cons_linear.c.

◆ SCIP_DECL_CONSENFOPS()

static SCIP_DECL_CONSENFOPS ( consEnfopsLinear  )
static

constraint enforcing method of constraint handler for pseudo solutions

Definition at line 15838 of file cons_linear.c.

◆ SCIP_DECL_CONSCHECK()

static SCIP_DECL_CONSCHECK ( consCheckLinear  )
static

◆ SCIP_DECL_CONSPROP()

static SCIP_DECL_CONSPROP ( consPropLinear  )
static

◆ SCIP_DECL_CONSPRESOL()

static SCIP_DECL_CONSPRESOL ( consPresolLinear  )
static

presolving method of constraint handler

Definition at line 16015 of file cons_linear.c.

Referenced by SCIP_DECL_CONSPROP().

◆ SCIP_DECL_CONSRESPROP()

static SCIP_DECL_CONSRESPROP ( consRespropLinear  )
static

propagation conflict resolving method of constraint handler

Definition at line 16517 of file cons_linear.c.

◆ SCIP_DECL_CONSLOCK()

static SCIP_DECL_CONSLOCK ( consLockLinear  )
static

variable rounding lock method of constraint handler

Definition at line 16531 of file cons_linear.c.

References NULL, performVarDeletions(), SCIP_CALL, SCIP_DECL_CONSDELVARS(), SCIP_DECL_CONSPRINT(), SCIP_OKAY, SCIPaddVarLocksType(), and SCIPisPositive().

◆ SCIP_DECL_CONSDELVARS()

static SCIP_DECL_CONSDELVARS ( consDelvarsLinear  )
static

variable deletion method of constraint handler

Definition at line 16579 of file cons_linear.c.

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

Referenced by SCIP_DECL_CONSLOCK().

◆ SCIP_DECL_CONSPRINT()

static SCIP_DECL_CONSPRINT ( consPrintLinear  )
static

constraint display method of constraint handler

Definition at line 16595 of file cons_linear.c.

Referenced by SCIP_DECL_CONSLOCK().

◆ SCIP_DECL_CONSCOPY()

static SCIP_DECL_CONSCOPY ( consCopyLinear  )
static

constraint copying method of constraint handler

Definition at line 16608 of file cons_linear.c.

Referenced by SCIP_DECL_CONSDELVARS().

◆ findOperators()

static SCIP_RETCODE findOperators ( const char *  str,
char **  firstoperator,
char **  secondoperator,
SCIP_Bool success 
)
static
Parameters
strnull terminated input string
firstoperatorpointer to store the string starting at the first operator
secondoperatorpointer to store the string starting at the second operator
successpointer to store if the line contains a valid operator order

Definition at line 16643 of file cons_linear.c.

References FALSE, NULL, SCIP_Bool, SCIP_DECL_CONSPARSE(), SCIP_OKAY, SCIP_Real, SCIPerrorMessage, and TRUE.

◆ SCIP_DECL_CONSPARSE()

static SCIP_DECL_CONSPARSE ( consParseLinear  )
static

constraint parsing method of constraint handler

Definition at line 16744 of file cons_linear.c.

Referenced by findOperators().

◆ SCIP_DECL_CONSGETVARS()

static SCIP_DECL_CONSGETVARS ( consGetVarsLinear  )
static

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

Definition at line 16903 of file cons_linear.c.

References 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 16926 of file cons_linear.c.

References EVENTHDLR_NAME, NULL, SCIPconsGetData(), and SCIPeventhdlrGetName().

◆ SCIP_DECL_EVENTEXEC()

static SCIP_DECL_EVENTEXEC ( eventExecLinear  )
static

! [Callback for the number of variables]

Definition at line 16945 of file cons_linear.c.

◆ SCIP_DECL_CONFLICTEXEC()

static SCIP_DECL_CONFLICTEXEC ( conflictExecLinear  )
static

Definition at line 17122 of file cons_linear.c.

◆ SCIP_DECL_QUADCONSUPGD()

◆ SCIP_DECL_NONLINCONSUPGD()