Constraint Handlers

Detailed Description

functions and files provided by the default constraint handlers of SCIP

A detailed description what a constraint handler does and how to add a constraint handler to SCIP can be found here.

Data Structures
struct	SCIP_ConsNonlinear_Auxexpr
struct	SCIP_ConsNonlinear_BilinTerm

Topics
	Inclusion functions
	functions to include specific constraint handlers into SCIP

Files
file	cons_and.c
	Constraint handler for AND-constraints, \(r = x_1 \wedge x_2 \wedge \dots \wedge x_n\).
file	cons_and.h
	Constraint handler for AND constraints, \(r = x_1 \wedge x_2 \wedge \dots \wedge x_n\).
file	cons_benders.h
	constraint handler for Benders' decomposition
file	cons_benderslp.h
	constraint handler for benderslp decomposition
file	cons_bounddisjunction.h
	constraint handler for bound disjunction constraints \((x_1 \{\leq,\geq\} b_1) \vee \ldots \vee (x_n \{\leq,\geq\} b_n)\)
file	cons_cardinality.h
	constraint handler for cardinality constraints
file	cons_conjunction.h
	constraint handler for conjunction constraints
file	cons_countsols.h
	Constraint handler for counting feasible solutions.
file	cons_cumulative.h
	constraint handler for cumulative constraints
file	cons_disjunction.h
	constraint handler for disjunction constraints
file	cons_exactlinear.h
	Constraint handler for linear constraints in their most general form, \(lhs <= a^T x <= rhs\).
file	cons_exactsol.h
	constraint handler for ensuring that primal solution is exact
file	cons_fixedvar.h
	constraint handler that checks bounds on fixed variables
file	cons_indicator.h
	constraint handler for indicator constraints
file	cons_integral.h
	constraint handler for the integrality constraint
file	cons_knapsack.h
	Constraint handler for knapsack constraints of the form \(a^T x \le b\), x binary and \(a \ge 0\).
file	cons_linear.h
	Constraint handler for linear constraints in their most general form, \(lhs <= a^T x <= rhs\).
file	cons_linking.h
	constraint handler for linking binary variables to a linking (continuous or integer) variable
file	cons_logicor.h
	Constraint handler for logicor constraints \(1^T x \ge 1\) (equivalent to set covering, but algorithms are suited for depth first search).
file	cons_nonlinear.h
	constraint handler for nonlinear constraints specified by algebraic expressions
file	cons_or.h
	Constraint handler for "or" constraints, \(r = x_1 \vee x_2 \vee \dots \vee x_n\).
file	cons_orbisack.h
	constraint handler for orbisack constraints
file	cons_orbitope.h
	interface for constraint handlers of type partitioning, packing, and full
file	cons_orbitope_full.h
	constraint handler for full orbitope constraints w.r.t. the full symmetric group
file	cons_orbitope_pp.h
	constraint handler for partitioning/packing orbitope constraints w.r.t. the full symmetric group
file	cons_pseudoboolean.h
	constraint handler for pseudoboolean constraints
file	cons_setppc.h
	Constraint handler for the set partitioning / packing / covering constraints \(1^T x\ \{=, \le, \ge\}\ 1\).
file	cons_sos1.h
	constraint handler for SOS type 1 constraints
file	cons_sos2.h
	constraint handler for SOS type 2 constraints
file	cons_superindicator.h
	constraint handler for indicator constraints over arbitrary constraint types
file	cons_symresack.h
	constraint handler for symresack constraints
file	cons_varbound.h
	Constraint handler for variable bound constraints \(lhs \leq x + c y \leq rhs\).
file	cons_xor.h
	Constraint handler for XOR constraints, \(rhs = x_1 \oplus x_2 \oplus \dots \oplus x_n\).
file	cons_rpa.h
	constraint handler for ringpacking
file	cons_optcumulative.c
	constraint handler for cumulative constraints with optional activities

Pseudoboolean Constraints
The constraint handler deals with pseudo boolean constraints. These are constraints of the form \[\mbox{lhs} \leq \sum_{k=0}^m c_k \cdot x_k + \sum_{i=0}^n c_i \cdot \prod_{j \in I_i} x_j \leq \mbox{rhs} \] where all \(x\) are binary.
enum	SCIP_LinearConsType {   SCIP_LINEARCONSTYPE_INVALIDCONS = -1 ,   SCIP_LINEARCONSTYPE_LINEAR = 0 ,   SCIP_LINEARCONSTYPE_LOGICOR = 1 ,   SCIP_LINEARCONSTYPE_KNAPSACK = 2 ,   SCIP_LINEARCONSTYPE_SETPPC = 3 }
typedef enum SCIP_LinearConsType	SCIP_LINEARCONSTYPE
SCIP_RETCODE	SCIPcreateConsPseudobooleanWithConss (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_CONS *lincons, SCIP_LINEARCONSTYPE linconstype, SCIP_CONS **andconss, SCIP_Real *andcoefs, int nandconss, SCIP_VAR *indvar, SCIP_Real weight, SCIP_Bool issoftcons, 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	SCIPcreateConsPseudoboolean (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR **linvars, int nlinvars, SCIP_Real *linvals, SCIP_VAR ***terms, int nterms, int *ntermvars, SCIP_Real *termvals, SCIP_VAR *indvar, SCIP_Real weight, SCIP_Bool issoftcons, 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	SCIPcreateConsBasicPseudoboolean (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR **linvars, int nlinvars, SCIP_Real *linvals, SCIP_VAR ***terms, int nterms, int *ntermvars, SCIP_Real *termvals, SCIP_VAR *indvar, SCIP_Real weight, SCIP_Bool issoftcons, SCIP_Real lhs, SCIP_Real rhs)
SCIP_RETCODE	SCIPaddCoefPseudoboolean (SCIP *const scip, SCIP_CONS *const cons, SCIP_VAR *const var, SCIP_Real const val)
SCIP_RETCODE	SCIPaddTermPseudoboolean (SCIP *const scip, SCIP_CONS *const cons, SCIP_VAR **const vars, int const nvars, SCIP_Real const val)
SCIP_VAR *	SCIPgetIndVarPseudoboolean (SCIP *const scip, SCIP_CONS *const cons)
SCIP_CONS *	SCIPgetLinearConsPseudoboolean (SCIP *const scip, SCIP_CONS *const cons)
SCIP_LINEARCONSTYPE	SCIPgetLinearConsTypePseudoboolean (SCIP *const scip, SCIP_CONS *const cons)
int	SCIPgetNLinVarsWithoutAndPseudoboolean (SCIP *const scip, SCIP_CONS *const cons)
SCIP_RETCODE	SCIPgetLinDatasWithoutAndPseudoboolean (SCIP *const scip, SCIP_CONS *const cons, SCIP_VAR **const linvars, SCIP_Real *const lincoefs, int *const nlinvars)
SCIP_RETCODE	SCIPgetAndDatasPseudoboolean (SCIP *const scip, SCIP_CONS *const cons, SCIP_CONS **const andconss, SCIP_Real *const andcoefs, int *const nandconss)
int	SCIPgetNAndsPseudoboolean (SCIP *const scip, SCIP_CONS *const cons)
SCIP_RETCODE	SCIPchgLhsPseudoboolean (SCIP *const scip, SCIP_CONS *const cons, SCIP_Real const lhs)
SCIP_RETCODE	SCIPchgRhsPseudoboolean (SCIP *const scip, SCIP_CONS *const cons, SCIP_Real const rhs)
SCIP_Real	SCIPgetLhsPseudoboolean (SCIP *const scip, SCIP_CONS *const cons)
SCIP_Real	SCIPgetRhsPseudoboolean (SCIP *const scip, SCIP_CONS *const cons)

Set Packing/Partitioning/Covering Constraints
This constraint handler handles three special classes of linear constraints, namely set partitioning, set packing, and set covering constraints. For a set of binary variables \(x_i, i=1,\dots,n\), a set partitioning constraint has the form \[ \sum_{i=1}^n x_i = 1, \] a set packing constraint has the form \[ \sum_{i=1}^n x_i \le 1, \] and a set covering constraint has the form \[ \sum_{i=1}^n x_i \ge 1. \]
enum	SCIP_SetppcType {   SCIP_SETPPCTYPE_PARTITIONING = 0 ,   SCIP_SETPPCTYPE_PACKING = 1 ,   SCIP_SETPPCTYPE_COVERING = 2 }
typedef enum SCIP_SetppcType	SCIP_SETPPCTYPE
SCIP_RETCODE	SCIPcreateConsSetpart (SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, 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	SCIPcreateConsBasicSetpart (SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars)
SCIP_RETCODE	SCIPcreateConsSetpack (SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, 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	SCIPcreateConsBasicSetpack (SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars)
SCIP_RETCODE	SCIPcreateConsSetcover (SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, 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	SCIPcreateConsBasicSetcover (SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars)
SCIP_RETCODE	SCIPaddCoefSetppc (SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)
int	SCIPgetNVarsSetppc (SCIP *scip, SCIP_CONS *cons)
SCIP_VAR **	SCIPgetVarsSetppc (SCIP *scip, SCIP_CONS *cons)
SCIP_SETPPCTYPE	SCIPgetTypeSetppc (SCIP *scip, SCIP_CONS *cons)
SCIP_Real	SCIPgetDualsolSetppc (SCIP *scip, SCIP_CONS *cons)
SCIP_Real	SCIPgetDualfarkasSetppc (SCIP *scip, SCIP_CONS *cons)
SCIP_ROW *	SCIPgetRowSetppc (SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE	SCIPcreateRowSetppc (SCIP *scip, SCIP_CONS *cons)
int	SCIPgetNFixedonesSetppc (SCIP *scip, SCIP_CONS *cons)
int	SCIPgetNFixedzerosSetppc (SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE	SCIPcleanupConssSetppc (SCIP *scip, SCIP_Bool onlychecked, SCIP_Bool *infeasible, int *naddconss, int *ndelconss, int *nchgcoefs, int *nfixedvars)

Linear Constraints
This constraint handler handles linear constraints in their most general form. That is, \[ lhs \leq \sum_{i=1}^n a_i x_i \leq rhs \] with \(a_i \in Q, i = 1,\dots,n\), \(lhs\in Q \cup \{-\infty\}\), \(rhs\in Q \cup \{\infty\}\), and decision variables \(x_i, i = 1,\dots,n\) which can be binary, integer, or continuous. Furthermore, this header offers the upgrade functionality of a general linear constraint into a more specific constraint, such as a knapsack constraint, via SCIP_DECL_LINCONSUPGD() and SCIPincludeLinconsUpgrade()
typedef struct SCIP_LinConsUpgrade	SCIP_LINCONSUPGRADE
SCIP_RETCODE	SCIPincludeLinconsUpgrade (SCIP *scip, SCIP_DECL_LINCONSUPGD((*linconsupgd)), int priority, const char *conshdlrname)
SCIP_RETCODE	SCIPcreateConsLinear (SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
SCIP_RETCODE	SCIPcreateConsBasicLinear (SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs)
SCIP_RETCODE	SCIPcopyConsLinear (SCIP *scip, SCIP_CONS **cons, SCIP *sourcescip, const char *name, int nvars, SCIP_VAR **sourcevars, SCIP_Real *sourcecoefs, SCIP_Real lhs, SCIP_Real rhs, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode, SCIP_Bool global, SCIP_Bool *valid)
SCIP_RETCODE	SCIPaddCoefLinear (SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE	SCIPchgCoefLinear (SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE	SCIPdelCoefLinear (SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)
SCIP_Real	SCIPgetLhsLinear (SCIP *scip, SCIP_CONS *cons)
SCIP_Real	SCIPgetRhsLinear (SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE	SCIPchgLhsLinear (SCIP *scip, SCIP_CONS *cons, SCIP_Real lhs)
SCIP_RETCODE	SCIPchgRhsLinear (SCIP *scip, SCIP_CONS *cons, SCIP_Real rhs)
int	SCIPgetNVarsLinear (SCIP *scip, SCIP_CONS *cons)
SCIP_VAR **	SCIPgetVarsLinear (SCIP *scip, SCIP_CONS *cons)
SCIP_Real *	SCIPgetValsLinear (SCIP *scip, SCIP_CONS *cons)
SCIP_Real	SCIPgetActivityLinear (SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol)
SCIP_Real	SCIPgetFeasibilityLinear (SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol)
SCIP_Real	SCIPgetDualsolLinear (SCIP *scip, SCIP_CONS *cons)
SCIP_Real	SCIPgetDualfarkasLinear (SCIP *scip, SCIP_CONS *cons)
SCIP_ROW *	SCIPgetRowLinear (SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE	SCIPcreateRowLinear (SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE	SCIPupgradeConsLinear (SCIP *scip, SCIP_CONS *cons, SCIP_CONS **upgdcons)
SCIP_RETCODE	SCIPclassifyConstraintTypesLinear (SCIP *scip, SCIP_LINCONSSTATS *linconsstats)
SCIP_RETCODE	SCIPcleanupConssLinear (SCIP *scip, SCIP_Bool onlychecked, SCIP_Bool *infeasible, int *ndelconss)
#define	SCIP_DECL_LINCONSUPGD(x)

Nonlinear Constraints
typedef struct SCIP_ConsNonlinear_Auxexpr	SCIP_CONSNONLINEAR_AUXEXPR
typedef struct SCIP_ConsNonlinear_BilinTerm	SCIP_CONSNONLINEAR_BILINTERM
SCIP_RETCODE	SCIPincludeConsUpgradeNonlinear (SCIP *scip, SCIP_DECL_NONLINCONSUPGD((*nlconsupgd)), int priority, SCIP_Bool active, const char *conshdlrname)
SCIP_RETCODE	SCIPcreateConsNonlinear (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_EXPR *expr, 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_RETCODE	SCIPcreateConsBasicNonlinear (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_EXPR *expr, SCIP_Real lhs, SCIP_Real rhs)
SCIP_RETCODE	SCIPcreateConsQuadraticNonlinear (SCIP *scip, SCIP_CONS **cons, const char *name, int nlinvars, SCIP_VAR **linvars, SCIP_Real *lincoefs, int nquadterms, SCIP_VAR **quadvars1, SCIP_VAR **quadvars2, SCIP_Real *quadcoefs, 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_RETCODE	SCIPcreateConsBasicQuadraticNonlinear (SCIP *scip, SCIP_CONS **cons, const char *name, int nlinvars, SCIP_VAR **linvars, SCIP_Real *lincoefs, int nquadterms, SCIP_VAR **quadvars1, SCIP_VAR **quadvars2, SCIP_Real *quadcoefs, SCIP_Real lhs, SCIP_Real rhs)
SCIP_RETCODE	SCIPcreateConsBasicSOCNonlinear (SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *coefs, SCIP_Real *offsets, SCIP_Real constant, SCIP_VAR *rhsvar, SCIP_Real rhscoeff, SCIP_Real rhsoffset)
SCIP_RETCODE	SCIPcreateConsBasicSignpowerNonlinear (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *x, SCIP_VAR *z, SCIP_Real exponent, SCIP_Real xoffset, SCIP_Real zcoef, SCIP_Real lhs, SCIP_Real rhs)
SCIP_Longint	SCIPgetCurBoundsTagNonlinear (SCIP_CONSHDLR *conshdlr)
SCIP_Longint	SCIPgetLastBoundRelaxTagNonlinear (SCIP_CONSHDLR *conshdlr)
void	SCIPincrementCurBoundsTagNonlinear (SCIP_CONSHDLR *conshdlr, SCIP_Bool boundrelax)
SCIP_HASHMAP *	SCIPgetVarExprHashmapNonlinear (SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE	SCIPprocessRowprepNonlinear (SCIP *scip, SCIP_NLHDLR *nlhdlr, SCIP_CONS *cons, SCIP_EXPR *expr, SCIP_ROWPREP *rowprep, SCIP_Bool overestimate, SCIP_VAR *auxvar, SCIP_Real auxvalue, SCIP_Bool allowweakcuts, SCIP_Bool branchscoresuccess, SCIP_Bool inenforcement, SCIP_SOL *sol, SCIP_RESULT *result)
SCIP_Bool	SCIPassumeConvexNonlinear (SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE	SCIPcollectBilinTermsNonlinear (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss)
int	SCIPgetNBilinTermsNonlinear (SCIP_CONSHDLR *conshdlr)
SCIP_CONSNONLINEAR_BILINTERM *	SCIPgetBilinTermsNonlinear (SCIP_CONSHDLR *conshdlr)
int	SCIPgetBilinTermIdxNonlinear (SCIP_CONSHDLR *conshdlr, SCIP_VAR *x, SCIP_VAR *y)
SCIP_CONSNONLINEAR_BILINTERM *	SCIPgetBilinTermNonlinear (SCIP_CONSHDLR *conshdlr, SCIP_VAR *x, SCIP_VAR *y)
SCIP_Real	SCIPevalBilinAuxExprNonlinear (SCIP *scip, SCIP_VAR *x, SCIP_VAR *y, SCIP_CONSNONLINEAR_AUXEXPR *auxexpr, SCIP_SOL *sol)
SCIP_RETCODE	SCIPinsertBilinearTermExistingNonlinear (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_VAR *x, SCIP_VAR *y, SCIP_VAR *auxvar, int nlockspos, int nlocksneg)
SCIP_RETCODE	SCIPinsertBilinearTermImplicitNonlinear (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_VAR *x, SCIP_VAR *y, SCIP_VAR *auxvar, SCIP_Real coefx, SCIP_Real coefy, SCIP_Real coefaux, SCIP_Real cst, SCIP_Bool overestimate)
SCIP_RETCODE	SCIPcomputeFacetVertexPolyhedralNonlinear (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_Bool overestimate, SCIP_DECL_VERTEXPOLYFUN((*function)), void *fundata, SCIP_Real *xstar, SCIP_Real *box, int nallvars, SCIP_Real targetvalue, SCIP_Bool *success, SCIP_Real *facetcoefs, SCIP_Real *facetconstant)
SCIP_EXPR *	SCIPgetExprNonlinear (SCIP_CONS *cons)
SCIP_Real	SCIPgetLhsNonlinear (SCIP_CONS *cons)
SCIP_Real	SCIPgetRhsNonlinear (SCIP_CONS *cons)
SCIP_RETCODE	SCIPgetNlRowNonlinear (SCIP *scip, SCIP_CONS *cons, SCIP_NLROW **nlrow)
SCIP_EXPRCURV	SCIPgetCurvatureNonlinear (SCIP_CONS *cons)
SCIP_RETCODE	SCIPcheckQuadraticNonlinear (SCIP *scip, SCIP_CONS *cons, SCIP_Bool *isquadratic)
SCIP_RETCODE	SCIPchgLhsNonlinear (SCIP *scip, SCIP_CONS *cons, SCIP_Real lhs)
SCIP_RETCODE	SCIPchgRhsNonlinear (SCIP *scip, SCIP_CONS *cons, SCIP_Real rhs)
SCIP_RETCODE	SCIPchgExprNonlinear (SCIP *scip, SCIP_CONS *cons, SCIP_EXPR *expr)
SCIP_RETCODE	SCIPaddLinearVarNonlinear (SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real coef)
SCIP_RETCODE	SCIPaddExprNonlinear (SCIP *scip, SCIP_CONS *cons, SCIP_EXPR *expr, SCIP_Real coef)
SCIP_RETCODE	SCIPgetAbsViolationNonlinear (SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Real *viol)
SCIP_RETCODE	SCIPgetRelViolationNonlinear (SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Real *viol)
void	SCIPgetLinvarMayDecreaseNonlinear (SCIP *scip, SCIP_CONS *cons, SCIP_VAR **var, SCIP_Real *coef)
void	SCIPgetLinvarMayIncreaseNonlinear (SCIP *scip, SCIP_CONS *cons, SCIP_VAR **var, SCIP_Real *coef)
int	SCIPgetExprNLocksPosNonlinear (SCIP_EXPR *expr)
int	SCIPgetExprNLocksNegNonlinear (SCIP_EXPR *expr)
SCIP_VAR *	SCIPgetExprAuxVarNonlinear (SCIP_EXPR *expr)
int	SCIPgetExprNEnfosNonlinear (SCIP_EXPR *expr)
void	SCIPgetExprEnfoDataNonlinear (SCIP_EXPR *expr, int idx, SCIP_NLHDLR **nlhdlr, SCIP_NLHDLREXPRDATA **nlhdlrexprdata, SCIP_NLHDLR_METHOD *nlhdlrparticipation, SCIP_Bool *sepabelowusesactivity, SCIP_Bool *sepaaboveusesactivity, SCIP_Real *auxvalue)
void	SCIPsetExprEnfoAuxValueNonlinear (SCIP_EXPR *expr, int idx, SCIP_Real auxvalue)
unsigned int	SCIPgetExprNPropUsesActivityNonlinear (SCIP_EXPR *expr)
unsigned int	SCIPgetExprNSepaUsesActivityNonlinear (SCIP_EXPR *expr)
unsigned int	SCIPgetExprNAuxvarUsesNonlinear (SCIP_EXPR *expr)
SCIP_RETCODE	SCIPregisterExprUsageNonlinear (SCIP *scip, SCIP_EXPR *expr, SCIP_Bool useauxvar, SCIP_Bool useactivityforprop, SCIP_Bool useactivityforsepabelow, SCIP_Bool useactivityforsepaabove)
SCIP_RETCODE	SCIPgetExprActivityNonlinear (SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Real *activity)
SCIP_RETCODE	SCIPgetExprAbsOrigViolationNonlinear (SCIP *scip, SCIP_EXPR *expr, SCIP_SOL *sol, SCIP_Longint soltag, SCIP_Real *viol, SCIP_Bool *violunder, SCIP_Bool *violover)
SCIP_RETCODE	SCIPgetExprAbsAuxViolationNonlinear (SCIP *scip, SCIP_EXPR *expr, SCIP_Real auxvalue, SCIP_SOL *sol, SCIP_Real *viol, SCIP_Bool *violunder, SCIP_Bool *violover)
SCIP_RETCODE	SCIPgetExprRelAuxViolationNonlinear (SCIP *scip, SCIP_EXPR *expr, SCIP_Real auxvalue, SCIP_SOL *sol, SCIP_Real *viol, SCIP_Bool *violunder, SCIP_Bool *violover)
SCIP_INTERVAL	SCIPgetExprBoundsNonlinear (SCIP *scip, SCIP_EXPR *expr)
SCIP_RETCODE	SCIPtightenExprIntervalNonlinear (SCIP *scip, SCIP_EXPR *expr, SCIP_INTERVAL newbounds, SCIP_Bool *cutoff, int *ntightenings)
SCIP_RETCODE	SCIPmarkExprPropagateNonlinear (SCIP *scip, SCIP_EXPR *expr)
void	SCIPaddExprViolScoreNonlinear (SCIP *scip, SCIP_EXPR *expr, SCIP_Real violscore)
SCIP_RETCODE	SCIPaddExprsViolScoreNonlinear (SCIP *scip, SCIP_EXPR **exprs, int nexprs, SCIP_Real violscore, SCIP_SOL *sol, SCIP_Bool *success)
SCIP_Real	SCIPgetExprViolScoreNonlinear (SCIP_EXPR *expr)
SCIP_Real	SCIPgetExprPartialDiffNonlinear (SCIP *scip, SCIP_EXPR *expr, SCIP_VAR *var)
SCIP_Real	SCIPgetExprPartialDiffGradientDirNonlinear (SCIP *scip, SCIP_EXPR *expr, SCIP_VAR *var)
SCIP_Real	SCIPevalExprQuadraticAuxNonlinear (SCIP *scip, SCIP_EXPR *expr, SCIP_SOL *sol)
#define	SCIP_DECL_VERTEXPOLYFUN(f)
#define	SCIP_MAXVERTEXPOLYDIM   14
#define	SCIP_DECL_NONLINCONSUPGD(x)

AND Constraints
This constraint handler deals with AND-constraints. These are constraint of the form: \[ r = x_1 \wedge x_2 \wedge \dots \wedge x_n \] where \(x_i\) is a binary variable for all \(i\). Hence, \(r\) is also of binary type. The variable \(r\) is called resultant and the \(x\)'s operators.
SCIP_RETCODE	SCIPcreateConsAnd (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *resvar, int nvars, SCIP_VAR **vars, 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	SCIPcreateConsBasicAnd (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *resvar, int nvars, SCIP_VAR **vars)
int	SCIPgetNVarsAnd (SCIP *scip, SCIP_CONS *cons)
SCIP_VAR **	SCIPgetVarsAnd (SCIP *scip, SCIP_CONS *cons)
SCIP_VAR *	SCIPgetResultantAnd (SCIP *scip, SCIP_CONS *cons)
SCIP_Bool	SCIPisAndConsSorted (SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE	SCIPsortAndCons (SCIP *scip, SCIP_CONS *cons)

Benders Constraints
Two constraint handlers are implemented for the generation of Benders' decomposition cuts. When included in a problem, the Benders' decomposition constraint handlers generate cuts during the enforcement of LP and relaxation solutions. Additionally, Benders' decomposition cuts can be generated when checking the feasibility of solutions with respect to the subproblem constraints. This constraint handler has an enforcement priority that is less than the integer constraint handler. This means that only integer feasible solutions from the LP solver are enforced by this constraint handler. This is the traditional behaviour of the branch-and-check approach to Benders' decomposition. Additionally, the check priority is set low, such that this expensive constraint handler is only called as a final check on primal feasible solutions. This constraint handler in the standard constraint handler that should be added when using Benders' decomposition. Additionally, there is a flag in SCIPincludeConshdlrBenders that permits the addition of the LP constraint handler, cons_benderslp. The use of both cons_benders and cons_benderslp allows the user to perform a multiphase Benders' decomposition algorithm.
SCIP_RETCODE	SCIPconsBendersEnforceSolution (SCIP *scip, SCIP_SOL *sol, SCIP_CONSHDLR *conshdlr, SCIP_RESULT *result, SCIP_BENDERSENFOTYPE type, SCIP_Bool checkint)

Bound Disjunction Constraints
This constraint handler handles bound disjunction constraints of the form \[ (x_1 \{\leq,\geq\} b_1) \vee \ldots \vee (x_n \{\leq,\geq\} b_n) \] with bounds \(b_i \in Q\), decision variables \(x_i\), which can be of any type, and bound types \(\leq\) or \(\geq\).
SCIP_RETCODE	SCIPcreateConsBounddisjunction (SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_BOUNDTYPE *boundtypes, SCIP_Real *bounds, 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	SCIPcreateConsBasicBounddisjunction (SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_BOUNDTYPE *boundtypes, SCIP_Real *bounds)
SCIP_RETCODE	SCIPcreateConsBounddisjunctionRedundant (SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_BOUNDTYPE *boundtypes, SCIP_Real *bounds, 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	SCIPcreateConsBasicBounddisjunctionRedundant (SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_BOUNDTYPE *boundtypes, SCIP_Real *bounds)
int	SCIPgetNVarsBounddisjunction (SCIP *scip, SCIP_CONS *cons)
SCIP_VAR **	SCIPgetVarsBounddisjunction (SCIP *scip, SCIP_CONS *cons)
SCIP_BOUNDTYPE *	SCIPgetBoundtypesBounddisjunction (SCIP *scip, SCIP_CONS *cons)
SCIP_Real *	SCIPgetBoundsBounddisjunction (SCIP *scip, SCIP_CONS *cons)

Cardinality Constraints
This constraint handler handles cardinality constraints of the form \[ |\mbox{supp}(x)| \leq b \] with integer right-hand side \(b\). Here, \(|\mbox{supp}(x)|\) denotes the number of nonzero entries of the vector \(x\). Cardinality constraints generalize special ordered set of type one (SOS1) constraints in which \(b = 1\).
SCIP_RETCODE	SCIPcreateConsCardinality (SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, int cardval, SCIP_VAR **indvars, SCIP_Real *weights, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
SCIP_RETCODE	SCIPcreateConsBasicCardinality (SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, int cardval, SCIP_VAR **indvars, SCIP_Real *weights)
SCIP_RETCODE	SCIPchgCardvalCardinality (SCIP *scip, SCIP_CONS *cons, int cardval)
SCIP_RETCODE	SCIPaddVarCardinality (SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_VAR *indvar, SCIP_Real weight)
SCIP_RETCODE	SCIPappendVarCardinality (SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_VAR *indvar)
int	SCIPgetNVarsCardinality (SCIP *scip, SCIP_CONS *cons)
SCIP_VAR **	SCIPgetVarsCardinality (SCIP *scip, SCIP_CONS *cons)
int	SCIPgetCardvalCardinality (SCIP *scip, SCIP_CONS *cons)
SCIP_Real *	SCIPgetWeightsCardinality (SCIP *scip, SCIP_CONS *cons)

Conjunction Constraints
A conjunction constraint \( C \) is a constraint of the form \[ C = C_1 \wedge \dots \wedge C_n \] where all the \( C_i \) are individual constraints themselves.
SCIP_RETCODE	SCIPcreateConsConjunction (SCIP *scip, SCIP_CONS **cons, const char *name, int nconss, SCIP_CONS **conss, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic)
SCIP_RETCODE	SCIPcreateConsBasicConjunction (SCIP *scip, SCIP_CONS **cons, const char *name, int nconss, SCIP_CONS **conss)
SCIP_RETCODE	SCIPaddConsElemConjunction (SCIP *scip, SCIP_CONS *cons, SCIP_CONS *addcons)

Constraint Handler for counting solutions
If this constraint handler is activated then it counts or collects all feasible solutions. We refer to How to use SCIP to count/enumerate feasible solutions for more details about using SCIP for counting feasible solutions.
	SCIP_DECL_DIALOGEXEC (SCIPdialogExecCountPresolve)
	SCIP_DECL_DIALOGEXEC (SCIPdialogExecCount)
	SCIP_DECL_DIALOGEXEC (SCIPdialogExecWriteAllsolutions)
SCIP_RETCODE	SCIPcount (SCIP *scip)
SCIP_Longint	SCIPgetNCountedSols (SCIP *scip, SCIP_Bool *valid)
void	SCIPgetNCountedSolsstr (SCIP *scip, char **buffer, int buffersize, int *requiredsize)
SCIP_Longint	SCIPgetNCountedFeasSubtrees (SCIP *scip)
void	SCIPgetCountedSparseSols (SCIP *scip, SCIP_VAR ***vars, int *nvars, SCIP_SPARSESOL ***sols, int *nsols)
SCIP_RETCODE	SCIPsetParamsCountsols (SCIP *scip)

Cumulative Constraints
Given: a set of jobs, represented by their integer start time variables \(S_j\), their array of processing times \(p_j\) and of their demands \(d_j\). an integer resource capacity \(C\) The cumulative constraint ensures that for each point in time \(t\) \(\sum_{j: S_j \leq t < S_j + p_j} d_j \leq C\) holds. Separation: can be done using binary start time model, see Pritskers, Watters and Wolfe or by just separating relatively weak cuts on the start time variables Propagation: time tabling, Klein & Scholl (1999) Edge-finding from Petr Vilim, adjusted and simplified for dynamic repropagation (2009) energetic reasoning, see Baptiste, Le Pape, Nuijten (2001)
SCIP_RETCODE	SCIPcreateConsCumulative (SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, 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	SCIPcreateConsBasicCumulative (SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity)
SCIP_RETCODE	SCIPsetHminCumulative (SCIP *scip, SCIP_CONS *cons, int hmin)
int	SCIPgetHminCumulative (SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE	SCIPsetHmaxCumulative (SCIP *scip, SCIP_CONS *cons, int hmax)
int	SCIPgetHmaxCumulative (SCIP *scip, SCIP_CONS *cons)
SCIP_VAR **	SCIPgetVarsCumulative (SCIP *scip, SCIP_CONS *cons)
int	SCIPgetNVarsCumulative (SCIP *scip, SCIP_CONS *cons)
int	SCIPgetCapacityCumulative (SCIP *scip, SCIP_CONS *cons)
int *	SCIPgetDurationsCumulative (SCIP *scip, SCIP_CONS *cons)
int *	SCIPgetDemandsCumulative (SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE	SCIPcheckCumulativeCondition (SCIP *scip, SCIP_SOL *sol, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, int hmin, int hmax, SCIP_Bool *violated, SCIP_CONS *cons, SCIP_Bool printreason)
SCIP_RETCODE	SCIPnormalizeCumulativeCondition (SCIP *scip, int nvars, SCIP_VAR **vars, int *durations, int *demands, int *capacity, int *nchgcoefs, int *nchgsides)
SCIP_RETCODE	SCIPsplitCumulativeCondition (SCIP *scip, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, int *hmin, int *hmax, int *split)
SCIP_RETCODE	SCIPpresolveCumulativeCondition (SCIP *scip, int nvars, SCIP_VAR **vars, int *durations, int hmin, int hmax, SCIP_Bool *downlocks, SCIP_Bool *uplocks, SCIP_CONS *cons, SCIP_Bool *irrelevants, int *nfixedvars, int *nchgsides, SCIP_Bool *cutoff)
SCIP_RETCODE	SCIPpropCumulativeCondition (SCIP *scip, SCIP_PRESOLTIMING presoltiming, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, int hmin, int hmax, SCIP_CONS *cons, int *nchgbds, SCIP_Bool *initialized, SCIP_Bool *explanation, SCIP_Bool *cutoff)
SCIP_RETCODE	SCIPrespropCumulativeCondition (SCIP *scip, int nvars, SCIP_VAR **vars, int *durations, int *demands, int capacity, int hmin, int hmax, SCIP_VAR *infervar, int inferinfo, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd, SCIP_Bool *explanation, SCIP_RESULT *result)
SCIP_RETCODE	SCIPvisualizeConsCumulative (SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE	SCIPsetSolveCumulative (SCIP *scip,)
SCIP_RETCODE	SCIPsolveCumulative (SCIP *scip, int njobs, SCIP_Real *ests, SCIP_Real *lsts, SCIP_Real *objvals, int *durations, int *demands, int capacity, int hmin, int hmax, SCIP_Real timelimit, SCIP_Real memorylimit, SCIP_Longint maxnodes, SCIP_Bool *solved, SCIP_Bool *infeasible, SCIP_Bool *unbounded, SCIP_Bool *error)
SCIP_RETCODE	SCIPcreateWorstCaseProfile (SCIP *scip, SCIP_PROFILE *profile, int nvars, SCIP_VAR **vars, int *durations, int *demands)
int	SCIPcomputeHmin (SCIP *scip, SCIP_PROFILE *profile, int capacity)
int	SCIPcomputeHmax (SCIP *scip, SCIP_PROFILE *profile, int capacity)
#define	SCIP_DECL_SOLVECUMULATIVE(x)

Disjunction Constraints
A disjunction constraint \( C \) is a constraint of the form \[ C = C_1 \vee \dots \vee C_n \] where all the \( C_i \) are individual constraints themselves.
SCIP_RETCODE	SCIPcreateConsDisjunction (SCIP *scip, SCIP_CONS **cons, const char *name, int nconss, SCIP_CONS **conss, SCIP_CONS *relaxcons, SCIP_Bool initial, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic)
SCIP_RETCODE	SCIPcreateConsBasicDisjunction (SCIP *scip, SCIP_CONS **cons, const char *name, int nconss, SCIP_CONS **conss, SCIP_CONS *relaxcons)
SCIP_RETCODE	SCIPaddConsElemDisjunction (SCIP *scip, SCIP_CONS *cons, SCIP_CONS *addcons)

Exact Linear Constraints
This constraint handler handles linear constraints in their most general form \[ lhs \leq \sum_{i=1}^n a_i x_i \leq rhs \] in a numerically exact way, where \(a_i \in Q, i = 1,\dots,n\), \(lhs\in Q \cup \{-\infty\}\), \(rhs\in Q \cup \{\infty\}\), and \(x_i, i = 1,\dots,n\) which can be binary, integer, or continuous decision variables.
SCIP_RETCODE	SCIPcreateConsExactLinear (SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_RATIONAL **vals, SCIP_RATIONAL *lhs, SCIP_RATIONAL *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	SCIPcreateConsBasicExactLinear (SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_RATIONAL **vals, SCIP_RATIONAL *lhs, SCIP_RATIONAL *rhs)
SCIP_RETCODE	SCIPcopyConsExactLinear (SCIP *scip, SCIP_CONS **cons, SCIP *sourcescip, const char *name, int nvars, SCIP_VAR **sourcevars, SCIP_INTERVAL *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	SCIPaddCoefExactLinear (SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_RATIONAL *val)
SCIP_RETCODE	SCIPchgCoefExactLinear (SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_RATIONAL *val)
SCIP_RETCODE	SCIPdelCoefExactLinear (SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)
SCIP_RATIONAL *	SCIPgetLhsExactLinear (SCIP *scip, SCIP_CONS *cons)
SCIP_RATIONAL *	SCIPgetRhsExactLinear (SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE	SCIPchgLhsExactLinear (SCIP *scip, SCIP_CONS *cons, SCIP_RATIONAL *lhs)
SCIP_RETCODE	SCIPchgRhsExactLinear (SCIP *scip, SCIP_CONS *cons, SCIP_RATIONAL *rhs)
int	SCIPgetNVarsExactLinear (SCIP *scip, SCIP_CONS *cons)
SCIP_VAR **	SCIPgetVarsExactLinear (SCIP *scip, SCIP_CONS *cons)
SCIP_INTERVAL *	SCIPgetValsRealExactLinear (SCIP *scip, SCIP_CONS *cons)
SCIP_RATIONAL **	SCIPgetValsExactLinear (SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE	SCIPgetActivityExactLinear (SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_RATIONAL *ret)
SCIP_RETCODE	SCIPgetFeasibilityExactLinear (SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_RATIONAL *ret)
void	SCIPgetFpDualsolExactLinear (SCIP *scip, SCIP_CONS *cons, SCIP_RATIONAL *ret)
void	SCIPgetFpDualfarkasExactLinear (SCIP *scip, SCIP_CONS *cons, SCIP_RATIONAL *ret)
SCIP_ROW *	SCIPgetRowExactLinear (SCIP *scip, SCIP_CONS *cons)
SCIP_ROWEXACT *	SCIPgetRowExactExactLinear (SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE	SCIPcertifyConsOrigExactLinear (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons)

Indicator Constraints
An indicator constraint is given by a binary variable \(z\) and an inequality \(ax \leq b\). It states that if \(z = 1\) then \(ax \leq b\) holds. This constraint is handled by adding a slack variable \(s:\; ax - s \leq b\) with \(s \geq 0\). The constraint is enforced by fixing \(s\) to 0 if \(z = 1\). Note The constraint only implements an implication not an equivalence, i.e., it does not ensure that \(z = 1\) if \(ax \leq b\) or equivalently if \(s = 0\) holds. This constraint is equivalent to a linear constraint \(ax - s \leq b\) and an SOS1 constraint on \(z\) and \(s\) (at most one should be nonzero). In the indicator context we can, however, separate more inequalities.
SCIP_RETCODE	SCIPcreateConsIndicator (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real rhs, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
SCIP_RETCODE	SCIPcreateConsBasicIndicator (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real rhs)
SCIP_RETCODE	SCIPcreateConsIndicatorGeneric (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real rhs, SCIP_Bool activeone, SCIP_Bool lessthanineq, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
SCIP_RETCODE	SCIPcreateConsIndicatorLinCons (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, SCIP_CONS *lincons, SCIP_VAR *slackvar, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
SCIP_RETCODE	SCIPcreateConsIndicatorGenericLinCons (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, SCIP_CONS *lincons, SCIP_VAR *slackvar, SCIP_Bool activeone, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
SCIP_RETCODE	SCIPcreateConsBasicIndicatorLinCons (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, SCIP_CONS *lincons, SCIP_VAR *slackvar)
SCIP_RETCODE	SCIPcreateConsIndicatorGenericLinConsPure (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, SCIP_CONS *lincons, SCIP_Bool activeone, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
SCIP_RETCODE	SCIPcreateConsIndicatorLinConsPure (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, SCIP_CONS *lincons, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
SCIP_RETCODE	SCIPaddVarIndicator (SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)
SCIP_CONS *	SCIPgetLinearConsIndicator (SCIP_CONS *cons)
SCIP_RETCODE	SCIPsetLinearConsIndicator (SCIP *scip, SCIP_CONS *cons, SCIP_CONS *lincons)
SCIP_RETCODE	SCIPsetBinaryVarIndicator (SCIP *scip, SCIP_CONS *cons, SCIP_VAR *binvar)
SCIP_Bool	SCIPgetActiveOnIndicator (SCIP_CONS *cons)
SCIP_VAR *	SCIPgetBinaryVarIndicator (SCIP_CONS *cons)
SCIP_VAR *	SCIPgetBinaryVarIndicatorGeneric (SCIP_CONS *cons)
SCIP_VAR *	SCIPgetSlackVarIndicator (SCIP_CONS *cons)
SCIP_RETCODE	SCIPsetSlackVarUb (SCIP *scip, SCIP_CONS *cons, SCIP_Real ub)
SCIP_Bool	SCIPisViolatedIndicator (SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol)
SCIP_RETCODE	SCIPmakeIndicatorFeasible (SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool *changed)
SCIP_RETCODE	SCIPmakeIndicatorsFeasible (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_SOL *sol, SCIP_Bool *changed)
SCIP_RETCODE	SCIPaddLinearConsIndicator (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *lincons)
SCIP_RETCODE	SCIPaddRowIndicator (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_ROW *row)

Knapsack Constraints
This constraint handler handles a special type of linear constraints, namely knapsack constraints. A knapsack constraint has the form \[ \sum_{i=1}^n a_i x_i \leq b \] with non-negative integer coefficients \(a_i\), integer right-hand side \(b\), and binary variables \(x_i\).
SCIP_RETCODE	SCIPcreateConsKnapsack (SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Longint *weights, SCIP_Longint capacity, 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	SCIPcreateConsBasicKnapsack (SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Longint *weights, SCIP_Longint capacity)
SCIP_RETCODE	SCIPaddCoefKnapsack (SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Longint weight)
SCIP_Longint	SCIPgetCapacityKnapsack (SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE	SCIPchgCapacityKnapsack (SCIP *scip, SCIP_CONS *cons, SCIP_Longint capacity)
int	SCIPgetNVarsKnapsack (SCIP *scip, SCIP_CONS *cons)
SCIP_VAR **	SCIPgetVarsKnapsack (SCIP *scip, SCIP_CONS *cons)
SCIP_Longint *	SCIPgetWeightsKnapsack (SCIP *scip, SCIP_CONS *cons)
SCIP_Real	SCIPgetDualsolKnapsack (SCIP *scip, SCIP_CONS *cons)
SCIP_Real	SCIPgetDualfarkasKnapsack (SCIP *scip, SCIP_CONS *cons)
SCIP_ROW *	SCIPgetRowKnapsack (SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE	SCIPcreateRowKnapsack (SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE	SCIPsolveKnapsackExactly (SCIP *scip, int nitems, SCIP_Longint *weights, SCIP_Real *profits, SCIP_Longint capacity, int *items, int *solitems, int *nonsolitems, int *nsolitems, int *nnonsolitems, SCIP_Real *solval, SCIP_Bool *success)
SCIP_RETCODE	SCIPsolveKnapsackApproximately (SCIP *scip, int nitems, SCIP_Longint *weights, SCIP_Real *profits, SCIP_Longint capacity, int *items, int *solitems, int *nonsolitems, int *nsolitems, int *nnonsolitems, SCIP_Real *solval)
SCIP_RETCODE	SCIPseparateKnapsackCuts (SCIP *scip, SCIP_CONS *cons, SCIP_SEPA *sepa, SCIP_VAR **vars, int nvars, SCIP_Longint *weights, SCIP_Longint capacity, SCIP_SOL *sol, SCIP_Bool usegubs, SCIP_Bool *cutoff, int *ncuts)
SCIP_RETCODE	SCIPseparateRelaxedKnapsack (SCIP *scip, SCIP_CONS *cons, SCIP_SEPA *sepa, int nknapvars, SCIP_VAR **knapvars, SCIP_Real *knapvals, SCIP_Real valscale, SCIP_Real rhs, SCIP_SOL *sol, SCIP_Bool *cutoff, int *ncuts)
SCIP_RETCODE	SCIPcleanupConssKnapsack (SCIP *scip, SCIP_Bool onlychecked, SCIP_Bool *infeasible, int *ndelconss)

Linking Constraints
The constraints handler stores linking constraints between a linking variable (continuous or integer) and an array of binary variables. Such a linking constraint has the form: \[y = \sum_{i=1}^n {c_i * x_i} \] with linking variable (continuous or integer) \( y \), binary variables \( x_1, \dots, x_n \) and offset \(b \in Q\), and with the additional side condition that exactly one binary variable has to be one (set partitioning condition). This constraint can be created only with the linking variable, if it is an integer variable. In this case the binary variables are only created on demand. That is, whenever someone asks for the binary variables. Therefore, such constraints can be used to get a "binary representation" of the domain of the linking variable which will be dynamically created.
SCIP_RETCODE	SCIPcreateConsLinking (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *linkvar, SCIP_VAR **binvars, SCIP_Real *vals, int nbinvars, 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	SCIPcreateConsBasicLinking (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *linkvar, SCIP_VAR **binvars, SCIP_Real *vals, int nbinvars)
SCIP_Bool	SCIPexistsConsLinking (SCIP *scip, SCIP_VAR *linkvar)
SCIP_CONS *	SCIPgetConsLinking (SCIP *scip, SCIP_VAR *linkvar)
SCIP_VAR *	SCIPgetLinkvarLinking (SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE	SCIPgetBinvarsLinking (SCIP *scip, SCIP_CONS *cons, SCIP_VAR ***binvars, int *nbinvars)
int	SCIPgetNBinvarsLinking (SCIP *scip, SCIP_CONS *cons)
SCIP_Real *	SCIPgetValsLinking (SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE	SCIPgetBinvarsDataLinking (SCIP_CONS *cons, SCIP_VAR ***binvars, SCIP_Real **vals, int *nbinvars)

Logicor Constraints
This constraint handler handles a special type of linear constraints, namely logic or constraints. These are equivalent to set covering constraints, but are handled by special algorithms which are better suited for depth first search. For a set of binary variables \(x_i, i=1,\dots,n\), a logic or constraint has the form \[ \sum_{i=1}^n x_i \ge 1. \]
SCIP_RETCODE	SCIPcreateConsLogicor (SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, 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	SCIPcreateConsBasicLogicor (SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars)
SCIP_RETCODE	SCIPaddCoefLogicor (SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)
int	SCIPgetNVarsLogicor (SCIP *scip, SCIP_CONS *cons)
SCIP_VAR **	SCIPgetVarsLogicor (SCIP *scip, SCIP_CONS *cons)
SCIP_Real	SCIPgetDualsolLogicor (SCIP *scip, SCIP_CONS *cons)
SCIP_Real	SCIPgetDualfarkasLogicor (SCIP *scip, SCIP_CONS *cons)
SCIP_ROW *	SCIPgetRowLogicor (SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE	SCIPcreateRowLogicor (SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE	SCIPcleanupConssLogicor (SCIP *scip, SCIP_Bool onlychecked, int *naddconss, int *ndelconss, int *nchgcoefs)

OR Constraints
This constraint handler deals with OR constraint. These are constraint of the form: \[ r = x_1 \vee x_2 \vee \dots \vee x_n \] where \(x_i\) is a binary variable for all \(i\). Hence, \(r\) is also of binary type. The variable \(r\) is called resultant and the \(x\)'s operators.
SCIP_RETCODE	SCIPcreateConsOr (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *resvar, int nvars, SCIP_VAR **vars, 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	SCIPcreateConsBasicOr (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *resvar, int nvars, SCIP_VAR **vars)
int	SCIPgetNVarsOr (SCIP *scip, SCIP_CONS *cons)
SCIP_VAR **	SCIPgetVarsOr (SCIP *scip, SCIP_CONS *cons)
SCIP_VAR *	SCIPgetResultantOr (SCIP *scip, SCIP_CONS *cons)

Orbisack Constraints
This constraint handler can be used to handle symmetries in certain 0/1-programs. The principle structure is that some variables can be ordered in matrix form with two columns, such that permuting both columns does not change the validity and objective function value of a solution. That is, there exists a permutation symmetry of the program that permutes the variables of the first and second column row-wise. In more mathematical terms the structure has to be as follows: There are 0/1-variables \(x_{ij}\), \(i \in \{1, \dots, n\}\), \(j \in \{1, 2\}\). Permuting columns of \(x\) does not change the validity and objective function value of any feasible solution.
SCIP_RETCODE	SCIPcheckSolutionOrbisack (SCIP *scip, SCIP_SOL *sol, SCIP_VAR **vars1, SCIP_VAR **vars2, int nrows, SCIP_Bool printreason, SCIP_Bool *feasible)
SCIP_RETCODE	SCIPcreateConsOrbisack (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *const *vars1, SCIP_VAR *const *vars2, int nrows, SCIP_Bool ispporbisack, SCIP_Bool isparttype, SCIP_Bool ismodelcons, 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	SCIPcreateConsBasicOrbisack (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR **vars1, SCIP_VAR **vars2, int nrows, SCIP_Bool ispporbisack, SCIP_Bool isparttype, SCIP_Bool ismodelcons)

Full Orbitope Constraints
This constraint handler can be used to handle symmetries in certain 0/1-programs. The principle structure is that some variables can be ordered in matrix form, such that permuting columns does not change the validity and objective function value of a solution. That is, the symmetry group of the program contains the full symmetric group obtained by permuting the columns of this matrix. These symmetries can be handled by so-called full orbitopes. In more mathematical terms the structure has to be as follows: There are 0/1-variables \(x_{ij}\), \(i \in \{1, \dots, p\}\), \(j \in \{1, \dots, q\}\). Permuting columns of \(x\) does not change the validity and objective function value of any feasible solution. We distinguish whether an orbitope is a model constraint or not. If it is a model constraint, then its information are copied to subSCIPs. Otherwise, the constraint was added just for the purpose of symmetry handling and we do not copy its information to subSCIPs.
SCIP_RETCODE	SCIPcreateConsOrbitopeFull (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR ***vars, int nrows, int ncols, SCIP_Bool resolveprop, SCIP_Bool ismodelcons, 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	SCIPcreateConsBasicOrbitopeFull (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR ***vars, int nrows, int ncols, SCIP_Bool resolveprop, SCIP_Bool ismodelcons)

Orbitope Constraints of Packing and Partitioning Type
This constraint handler can be used to handle symmetries in certain 0/1-programs. The principle structure is that some variables can be ordered in matrix form, such that permuting columns does not change the validity and objective function value of a solution. That is, the symmetry group of the program contains the full symmetric group obtained by permuting the columns of this matrix. These symmetries can be handled by so-called full orbitopes. Moreover, if the variables in each row are contained in set packing or partitioning constraint, these symmetries can be handled by specialized packing or partitioning orbitopes. In more mathematical terms the structure has to be as follows: There are 0/1-variables \(x_{ij}\), \(i \in \{1, \dots, p\}\), \(j \in \{1, \dots, q\}\). The variables may be coupled through set packing or partitioning constraints: \[ \sum_{j = 1}^q x_{ij} \leq 1 \quad \mbox{or} \quad \sum_{j = 1}^q x_{ij} = 1 \quad \mbox{for all }i = 1, \ldots, p. \] Permuting columns of \(x\) does not change the validity and objective function value of any feasible solution. We distinguish whether an orbitope is a model constraint or not. If it is a model constraint, then its information are copied to subSCIPs. Otherwise, the constraint was added just for the purpose of symmetry handling and we do not copy its information to subSCIPs.
SCIP_RETCODE	SCIPcreateConsOrbitopePP (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR ***vars, SCIP_ORBITOPETYPE orbitopetype, int nrows, int ncols, SCIP_Bool resolveprop, SCIP_Bool ismodelcons, 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	SCIPcreateConsBasicOrbitopePP (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR ***vars, SCIP_ORBITOPETYPE orbitopetype, int nrows, int ncols, SCIP_Bool resolveprop, SCIP_Bool ismodelcons)

Specially Ordered Set (SOS) Type 1 Constraints
A specially ordered set of type 1 (SOS1) is a sequence of variables such that at most one variable is nonzero. The special case of two variables arises, for instance, from equilibrium or complementary conditions like \(x \cdot y = 0\). Note that it is in principle allowed that a variable appears twice, but it then can be fixed to 0.
SCIP_RETCODE	SCIPcreateConsSOS1 (SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *weights, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
SCIP_RETCODE	SCIPcreateConsBasicSOS1 (SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *weights)
SCIP_RETCODE	SCIPaddVarSOS1 (SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real weight)
SCIP_RETCODE	SCIPappendVarSOS1 (SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)
int	SCIPgetNVarsSOS1 (SCIP *scip, SCIP_CONS *cons)
SCIP_VAR **	SCIPgetVarsSOS1 (SCIP *scip, SCIP_CONS *cons)
SCIP_Real *	SCIPgetWeightsSOS1 (SCIP *scip, SCIP_CONS *cons)
SCIP_DIGRAPH *	SCIPgetConflictgraphSOS1 (SCIP_CONSHDLR *conshdlr)
int	SCIPgetNSOS1Vars (SCIP_CONSHDLR *conshdlr)
SCIP_Bool	SCIPvarIsSOS1 (SCIP_CONSHDLR *conshdlr, SCIP_VAR *var)
int	SCIPvarGetNodeSOS1 (SCIP_CONSHDLR *conshdlr, SCIP_VAR *var)
SCIP_VAR *	SCIPnodeGetVarSOS1 (SCIP_DIGRAPH *conflictgraph, int node)
SCIP_RETCODE	SCIPmakeSOS1sFeasible (SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_SOL *sol, SCIP_Bool *changed, SCIP_Bool *success)

Specially Ordered Set (SOS) Type 2 Constraints
A specially ordered set of type 2 (SOS2) is a sequence of variables such that at most two variables are nonzero and if two variables are nonzero they must be adjacent in the specified sequence. Note that it is in principle allowed that a variable appears twice, but it then can be fixed to 0 if it is at least two apart in the sequence.
SCIP_RETCODE	SCIPcreateConsSOS2 (SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *weights, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
SCIP_RETCODE	SCIPcreateConsBasicSOS2 (SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *weights)
SCIP_RETCODE	SCIPaddVarSOS2 (SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real weight)
SCIP_RETCODE	SCIPappendVarSOS2 (SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var)
int	SCIPgetNVarsSOS2 (SCIP *scip, SCIP_CONS *cons)
SCIP_VAR **	SCIPgetVarsSOS2 (SCIP *scip, SCIP_CONS *cons)
SCIP_Real *	SCIPgetWeightsSOS2 (SCIP *scip, SCIP_CONS *cons)

Superindicator Constraints
Superindicator constraints are constraints of the form \[ x_i = 1 \Rightarrow C(x) \] where \( x_i \) is a binary variable and \( C(\dot) \) a constraint. The superindicator constraint is satisfied if and only if x_i is zero or C is satisfied.
SCIP_RETCODE	SCIPcreateConsSuperindicator (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, SCIP_CONS *slackcons, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
SCIP_RETCODE	SCIPcreateConsBasicSuperindicator (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, SCIP_CONS *slackcons)
SCIP_VAR *	SCIPgetBinaryVarSuperindicator (SCIP_CONS *cons)
SCIP_CONS *	SCIPgetSlackConsSuperindicator (SCIP_CONS *cons)
	SCIP_DECL_DIALOGEXEC (SCIPdialogExecChangeMinUC)

Symresack Constraints
Given a permutation that acts on the order of the variables of a (mixed) 0/1-program such that the permutation is a symmetry of the program, this constraint handler can be used to handle the symmetries corresponding to the permutation. The symmetries are handled by enforcing that a binary solution is lexicographically not smaller than its permutation. In a presolving step, we check whether the permutation acts only on binary points. Otherwise, we eliminate the non-binary variables from the permutation. Furthermore, we delete fixed points from the permutation. Moreover, the constraint handler checks whether each cycle of the permutation is contained in a set packing or partitioning constraint. In this case, the symresack is strengthened to a ppsymresack and strong symmetry handling inequalities are added during the initialization of the constraint handler. Precondition The permutation is encoded by an array perm for which perm[i] = j if and only if the image of i under the permutation is j. The permutation given to the constraint handler has to be a symmetry of the underlying problem. This is NOT checked by the constraint handler.
SCIP_RETCODE	SCIPcreateSymbreakCons (SCIP *scip, SCIP_CONS **cons, const char *name, int *perm, SCIP_VAR **vars, int nvars, SCIP_Bool ismodelcons, 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	SCIPcreateConsSymresack (SCIP *scip, SCIP_CONS **cons, const char *name, int *perm, SCIP_VAR **vars, int nvars, SCIP_Bool ismodelcons, 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	SCIPcreateConsBasicSymresack (SCIP *scip, SCIP_CONS **cons, const char *name, int *perm, SCIP_VAR **vars, int nvars, SCIP_Bool ismodelcons)

Variable Bound Constraints
This constraint handler handles a special type of linear constraints, namely variable bound constraints. A variable bound constraint has the form \[ lhs \leq x + c y \leq rhs \] with coefficient \(c \in Q\), \(lhs\in Q \cup \{-\infty\}\), \(rhs\in Q \cup \{\infty\}\), and decision variables \(x\) (non-binary) and \(y\) (binary or integer).
SCIP_RETCODE	SCIPcreateConsVarbound (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *var, SCIP_VAR *vbdvar, SCIP_Real vbdcoef, 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	SCIPcreateConsBasicVarbound (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *var, SCIP_VAR *vbdvar, SCIP_Real vbdcoef, SCIP_Real lhs, SCIP_Real rhs)
SCIP_Real	SCIPgetLhsVarbound (SCIP *scip, SCIP_CONS *cons)
SCIP_Real	SCIPgetRhsVarbound (SCIP *scip, SCIP_CONS *cons)
SCIP_VAR *	SCIPgetVarVarbound (SCIP *scip, SCIP_CONS *cons)
SCIP_VAR *	SCIPgetVbdvarVarbound (SCIP *scip, SCIP_CONS *cons)
SCIP_Real	SCIPgetVbdcoefVarbound (SCIP *scip, SCIP_CONS *cons)
SCIP_Real	SCIPgetDualsolVarbound (SCIP *scip, SCIP_CONS *cons)
SCIP_Real	SCIPgetDualfarkasVarbound (SCIP *scip, SCIP_CONS *cons)
SCIP_ROW *	SCIPgetRowVarbound (SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE	SCIPcreateRowVarbound (SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE	SCIPcleanupConssVarbound (SCIP *scip, SCIP_Bool onlychecked, SCIP_Bool *infeasible, int *naddconss, int *ndelconss, int *nchgbds)

XOR Constraints
This constraint handler deals with "xor" constraint. These are constraint of the form: \[ rhs = x_1 \oplus x_2 \oplus \dots \oplus x_n \] where \(x_i\) is a binary variable for all \(i\) and \(rhs\) is bool. The variables \(x\)'s are called operators. This constraint is satisfied if \(rhs\) is TRUE and an odd number of the operators are TRUE or if the \(rhs\) is FALSE and a even number of operators are TRUE. Hence, if the sum of \(rhs\) and operators is even.
SCIP_RETCODE	SCIPcreateConsXor (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_Bool rhs, int nvars, SCIP_VAR **vars, 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	SCIPcreateConsBasicXor (SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_Bool rhs, int nvars, SCIP_VAR **vars)
int	SCIPgetNVarsXor (SCIP *scip, SCIP_CONS *cons)
SCIP_VAR **	SCIPgetVarsXor (SCIP *scip, SCIP_CONS *cons)
SCIP_VAR *	SCIPgetIntVarXor (SCIP *scip, SCIP_CONS *cons)
SCIP_Bool	SCIPgetRhsXor (SCIP *scip, SCIP_CONS *cons)

Macro Definition Documentation

SCIP_DECL_SOLVECUMULATIVE

#define SCIP_DECL_SOLVECUMULATIVE

(

x

)

Value:

      SCIP_RETCODE x (int njobs, SCIP_Real* ests, SCIP_Real* lsts, SCIP_Real* objvals, \
      int* durations, int* demands, int capacity, int hmin, int hmax, \
      SCIP_Real timelimit, SCIP_Real memorylimit, SCIP_Longint maxnodes, \
      SCIP_Bool* solved, SCIP_Bool* infeasible, SCIP_Bool* unbounded, SCIP_Bool* error)

solves given cumulative condition as independent sub problem

Note

The time and memory limit should be respected.

If the problem was solved to the earliest start times (ests) and latest start times (lsts) array contain the solution values; If the problem was not solved these two arrays contain the global bounds at the time the sub solver was interrupted.

input:

• njobs : number of jobs (activities)
• objvals : array of objective coefficients for each job (linear objective function), or NULL if none
• durations : array of durations
• demands : array of demands
• capacity : cumulative capacity
• hmin : left bound of time axis to be considered (including hmin)
• hmax : right bound of time axis to be considered (not including hmax)
• timelimit : time limit for solving in seconds
• memorylimit : memory limit for solving in mega bytes (MB)
• maxnodes : maximum number of branch-and-bound nodes to solve the single cumulative constraint (-1: no limit)

input/output:

• ests : array of earliest start times for each job
• lsts : array of latest start times for each job

output:

• solved : pointer to store if the problem is solved (to optimality)
• infeasible : pointer to store if the problem is infeasible
• unbounded : pointer to store if the problem is unbounded
• error : pointer to store if an error occurred

Definition at line 356 of file cons_cumulative.h.

SCIP_DECL_LINCONSUPGD

#define SCIP_DECL_LINCONSUPGD

(

x

)

Value:

      SCIP_RETCODE x (SCIP* scip, SCIP_CONS* cons, int nvars, SCIP_VAR** vars, SCIP_Real* vals, SCIP_Real lhs, SCIP_Real rhs, \
      int nposbin, int nnegbin, int nposint, int nnegint, int nposimpl, int nnegimpl, int nposimplbin, int nnegimplbin, int nposcont, int nnegcont, \
      int ncoeffspone, int ncoeffsnone, int ncoeffspint, int ncoeffsnint, int ncoeffspfrac, int ncoeffsnfrac, \
      SCIP_Real poscoeffsum, SCIP_Real negcoeffsum, SCIP_Bool integral, SCIP_CONS** upgdcons)

upgrading method for linear constraints into more specific constraints

input:

• scip : SCIP main data structure
• cons : the linear constraint to upgrade
• nvars : number of variables in the constraint
• vars : array with constraint variables
• vals : array with constraint coefficients
• lhs : left hand side of linear constraint
• rhs : right hand side of linear constraint
• nposbin : number of binary variables with positive coefficient
• nnegbin : number of binary variables with negative coefficient
• nposint : number of integer variables with positive coefficient
• nnegint : number of integer variables with negative coefficient
• nposimpl : number of implicit integer variables with positive coefficient (including implicit binary variables)
• nnegimpl : number of implicit integer variables with negative coefficient (including implicit binary variables)
• nposimplbin : number of implicit binary variables with positive coefficient
• nnegimplbin : number of implicit binary variables with negative coefficient
• nposcont : number of continuous variables with positive coefficient
• nnegcont : number of continuous variables with negative coefficient
• ncoeffspone : number of +1 coefficients
• ncoeffsnone : number of -1 coefficients
• ncoeffspint : number of positive integral coefficients other than +1
• ncoeffsnint : number of negative integral coefficients other than -1
• ncoeffspfrac : number of positive fractional coefficients
• ncoeffsnfrac : number of negative fractional coefficients
• poscoeffsum : sum of all positive coefficients
• negcoeffsum : sum of all negative coefficients
• integral : TRUE iff constraints activity value is always integral
• upgdcons : pointer to store the upgraded constraint

Definition at line 120 of file cons_linear.h.

SCIP_DECL_VERTEXPOLYFUN

#define SCIP_DECL_VERTEXPOLYFUN

(

f

)

Value:

SCIP_Real f (SCIP_Real* args, int nargs, void* funcdata)

evaluation callback for (vertex-polyhedral) functions used as input for facet computation of its envelopes

Parameters

[in]	args	the point to be evaluated
[in]	nargs	the number of arguments of the function (length of array args)
[in]	funcdata	user-data of function evaluation callback

Returns

value of function in point given by args or SCIP_INVALID if could not be evaluated

Definition at line 102 of file cons_nonlinear.h.

SCIP_MAXVERTEXPOLYDIM

#define SCIP_MAXVERTEXPOLYDIM   14

maximum dimension of vertex-polyhedral function for which we can try to compute a facet of its convex or concave envelope

Definition at line 105 of file cons_nonlinear.h.

Referenced by buildVertexPolyhedralSeparationLP(), computeVertexPolyhedralFacetLP(), estimateVertexPolyhedralProduct(), SCIP_DECL_CONSEXIT(), SCIP_DECL_CONSFREE(), SCIP_DECL_NLHDLRDETECT(), and SCIPcomputeFacetVertexPolyhedralNonlinear().

SCIP_DECL_NONLINCONSUPGD

#define SCIP_DECL_NONLINCONSUPGD

(

x

)

Value:

      SCIP_RETCODE x (SCIP* scip, SCIP_CONS* cons, int nvarexprs, \
      int* nupgdconss, SCIP_CONS** upgdconss, int upgdconsssize)

upgrading method for nonlinear constraints into more specific constraints

The method might upgrade a nonlinear constraint into a set of upgrade constraints. The caller provided an array upgdconss of size upgdconsssize to store upgrade constraints. If an upgrade is not possible, set *nupgdconss to zero. If more than upgdconsssize many constraints shall replace cons, the function should return the required number as negated value in *nupgdconss, e.g., if cons should be replaced by 3 constraints, the function should set *nupgdconss to -3 and return with SCIP_OKAY.

Parameters

[in]	scip	SCIP main data structure
[in]	cons	the nonlinear constraint to upgrade
[in]	nvarexprs	total number of variable expressions in the nonlinear constraint
[out]	nupgdconss	pointer to store number of constraints that replace this constraint
[out]	upgdconss	array to store constraints that replace this constraint
[in]	upgdconsssize	length of the provided upgdconss array

Definition at line 124 of file cons_nonlinear.h.

Typedef Documentation

SCIP_LINCONSUPGRADE

typedef struct SCIP_LinConsUpgrade SCIP_LINCONSUPGRADE

linear constraint update method

Definition at line 87 of file cons_linear.h.

SCIP_CONSNONLINEAR_AUXEXPR

typedef struct SCIP_ConsNonlinear_Auxexpr SCIP_CONSNONLINEAR_AUXEXPR

Definition at line 65 of file cons_nonlinear.h.

SCIP_CONSNONLINEAR_BILINTERM

typedef struct SCIP_ConsNonlinear_BilinTerm SCIP_CONSNONLINEAR_BILINTERM

bilinear term structure

Definition at line 93 of file cons_nonlinear.h.

SCIP_LINEARCONSTYPE

typedef enum SCIP_LinearConsType SCIP_LINEARCONSTYPE

Definition at line 90 of file cons_pseudoboolean.h.

SCIP_SETPPCTYPE

typedef enum SCIP_SetppcType SCIP_SETPPCTYPE

Definition at line 91 of file cons_setppc.h.

Enumeration Type Documentation

SCIP_LinearConsType

enum SCIP_LinearConsType

solution status after solving LP

Enumerator
SCIP_LINEARCONSTYPE_INVALIDCONS	this is no valid linear constraint type
SCIP_LINEARCONSTYPE_LINEAR	this is the common linear constraint
SCIP_LINEARCONSTYPE_LOGICOR	this is a logicor constraint
SCIP_LINEARCONSTYPE_KNAPSACK	this is a knapsack constraint
SCIP_LINEARCONSTYPE_SETPPC	this is a setppc constraint

Definition at line 77 of file cons_pseudoboolean.h.

SCIP_SetppcType

enum SCIP_SetppcType

type of setppc constraint: set partitioning, set packing, or set covering

Enumerator
SCIP_SETPPCTYPE_PARTITIONING	constraint is a set partitioning constraint: sum(x) == 1
SCIP_SETPPCTYPE_PACKING	constraint is a set packing constraint: sum(x) <= 1
SCIP_SETPPCTYPE_COVERING	constraint is a set covering constraint: sum(x) >= 1

Definition at line 85 of file cons_setppc.h.

Function Documentation

SCIPcreateConsAnd()

SCIP_RETCODE SCIPcreateConsAnd	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_VAR *	resvar,
		int	nvars,
		SCIP_VAR **	vars,
		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 )

creates and captures an and constraint

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

creates and captures a AND-constraint

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
resvar	resultant variable of the operation
nvars	number of operator variables in the constraint
vars	array with operator variables of constraint
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 5059 of file cons_and.c.

References assert(), consdataCreate(), CONSHDLR_NAME, i, NULL, nvars, propagate, SCIP_Bool, SCIP_CALL, SCIP_IMPLINTTYPE_STRONG, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIP_VARTYPE_BINARY, SCIPchgVarImplType(), SCIPconshdlrGetData(), SCIPcreateCons(), SCIPerrorMessage, SCIPfindConshdlr(), SCIPisTransformed(), SCIPvarGetName(), SCIPvarGetProbvar(), SCIPvarGetType(), SCIPvarIsBinary(), SCIPvarIsImpliedIntegral(), separate(), and vars.

Referenced by CREATE_CONSTRAINT(), createAndAddAndCons(), extractGates(), findAggregation(), SCIP_DECL_CONSCOPY(), SCIP_DECL_CONSPARSE(), SCIPcreateConsBasicAnd(), setObjective(), and upgradeCons().

SCIPcreateConsBasicAnd()

SCIP_RETCODE SCIPcreateConsBasicAnd	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_VAR *	resvar,
		int	nvars,
		SCIP_VAR **	vars )

creates and captures an and constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsAnd(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h

See also

SCIPcreateConsAnd() for information about the basic constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

creates and captures an AND-constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsAnd(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h

See also

SCIPcreateConsAnd() for information about the basic constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
resvar	resultant variable of the operation
nvars	number of operator variables in the constraint
vars	array with operator variables of constraint

Definition at line 5180 of file cons_and.c.

References assert(), FALSE, NULL, nvars, SCIP_CALL, SCIP_OKAY, SCIPcreateConsAnd(), TRUE, and vars.

Referenced by getBinaryProductExprDo(), and AMPLProblemHandler::OnBinaryLogical().

SCIPgetNVarsAnd()

int SCIPgetNVarsAnd	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets number of variables in and constraint

gets number of variables in AND-constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 5199 of file cons_and.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by checkAndConss(), checkOrigPbCons(), chgLhs(), chgRhs(), computeAndConstraintInfos(), computeConsAndDataChanges(), consdataFree(), consdataPrint(), constructHypergraph(), countNonlinearities(), createCoveringProblem(), matrixCreate(), printAndCons(), printRowAnd(), SCIP_DECL_CONSCOPY(), SCIP_DECL_CONSGETNVARS(), SCIP_DECL_CONSGETVARS(), SCIPcreateConsPseudobooleanWithConss(), SCIPwriteGms(), SCIPwriteMps(), SCIPwritePip(), and transformToOrig().

SCIPgetVarsAnd()

SCIP_VAR ** SCIPgetVarsAnd	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets array of variables in and constraint

gets array of variables in AND-constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 5223 of file cons_and.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by checkAndConss(), checkOrigPbCons(), chgLhs(), chgRhs(), computeAndConstraintInfos(), computeConsAndDataChanges(), consdataFree(), consdataPrint(), constructHypergraph(), countNonlinearities(), createCoveringProblem(), matrixCreate(), printAndCons(), printRowAnd(), SCIP_DECL_CONSCOPY(), SCIP_DECL_CONSGETVARS(), SCIPcreateConsPseudobooleanWithConss(), SCIPwriteGms(), SCIPwriteMps(), SCIPwritePip(), and transformToOrig().

SCIPgetResultantAnd()

SCIP_VAR * SCIPgetResultantAnd	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets the resultant variable in and constraint

gets the resultant variable in AND-constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 5248 of file cons_and.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by addCliques(), addCoefTerm(), checkAndConss(), checkOrigPbCons(), computeAndConstraintInfos(), consdataCreate(), consdataFree(), constructHypergraph(), copyConsPseudoboolean(), correctConshdlrdata(), correctLocksAndCaptures(), countNonlinearities(), createAndAddAndCons(), createCoveringProblem(), lockRoundingAndCons(), matrixCreate(), printAndCons(), printRowAnd(), SCIP_DECL_CONSCOPY(), SCIP_DECL_CONSINIT(), SCIP_DECL_CONSLOCK(), SCIP_DECL_SORTPTRCOMP(), SCIPcreateConsPseudoboolean(), SCIPcreateConsPseudobooleanWithConss(), SCIPwriteGms(), SCIPwriteMps(), SCIPwritePip(), transformToOrig(), tryUpgradingSetppc(), unlockRoundingAndCons(), and updateConsanddataUses().

SCIPisAndConsSorted()

SCIP_Bool SCIPisAndConsSorted	(	SCIP *	scip,
		SCIP_CONS *	cons )

return if the variables of the AND-constraint are sorted with respect to their indices

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 5271 of file cons_and.c.

References assert(), CONSHDLR_NAME, FALSE, NULL, SCIP_Bool, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by computeConsAndDataChanges().

SCIPsortAndCons()

SCIP_RETCODE SCIPsortAndCons	(	SCIP *	scip,
		SCIP_CONS *	cons )

sort the variables of the AND-constraint with respect to their indices

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 5295 of file cons_and.c.

References assert(), consdataSort(), CONSHDLR_NAME, NULL, SCIP_INVALIDDATA, SCIP_OKAY, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by computeConsAndDataChanges().

SCIPconsBendersEnforceSolution()

SCIP_RETCODE SCIPconsBendersEnforceSolution	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_RESULT *	result,
		SCIP_BENDERSENFOTYPE	type,
		SCIP_Bool	checkint )

enforces Benders' constraints for given solution

This method is called from cons_benderslp and cons_benders. If the method is called from cons_benderslp, then the solutions are not guaranteed to be integer feasible. This is because the default priority is set greater than the integer constraint handler. If this method is called from cons_benders, then, because the default enforcement priority is set less than that of the integer constraint handler, then it can be assumed that the solutions are integer feasible.

The checkint flag indicates whether integer feasibility can be assumed. If it is not assumed, i.e. checkint == FALSE, then only the convex relaxations of the subproblems are solved. If integer feasibility is assumed, i.e. checkint == TRUE, then the convex relaxations and the full CIP are solved to generate Benders' cuts and check solution feasibility.

Parameters

scip	the SCIP instance
sol	the primal solution to enforce, or NULL for the current LP/pseudo sol
conshdlr	the constraint handler
result	the result of the enforcement
type	the type of solution being enforced
checkint	should integrality be considered when checking the subproblems

Definition at line 286 of file cons_benders.c.

References assert(), constructValidSolution(), FALSE, i, NULL, result, SCIP_BENDERSENFOTYPE_CHECK, SCIP_BENDERSENFOTYPE_LP, SCIP_BENDERSENFOTYPE_PSEUDO, SCIP_BENDERSENFOTYPE_RELAX, SCIP_Bool, SCIP_CALL, SCIP_DIDNOTRUN, SCIP_FEASIBLE, SCIP_INFEASIBLE, SCIP_LPSOLSTAT_UNBOUNDEDRAY, SCIP_OKAY, SCIPbendersCutLP(), SCIPbendersCutPseudo(), SCIPbendersCutRelaxation(), SCIPbendersSubproblemsAreInfeasible(), SCIPgetBenders(), SCIPgetLPSolstat(), SCIPgetNActiveBenders(), SCIPsolveBendersSubproblems(), SCIPwarningMessage(), sol, TRUE, and unboundedAuxiliaryVariables().

Referenced by SCIP_DECL_CONSENFOLP(), SCIP_DECL_CONSENFOLP(), SCIP_DECL_CONSENFOPS(), SCIP_DECL_CONSENFOPS(), SCIP_DECL_CONSENFORELAX(), and SCIP_DECL_CONSENFORELAX().

SCIPcreateConsBounddisjunction()

SCIP_RETCODE SCIPcreateConsBounddisjunction	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_BOUNDTYPE *	boundtypes,
		SCIP_Real *	bounds,
		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 )

creates and captures a bound disjunction constraint

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nvars	number of variables in the constraint
vars	variables of the literals in the constraint
boundtypes	types of bounds of the literals (lower or upper bounds)
bounds	bounds of the literals
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 3316 of file cons_bounddisjunction.c.

References assert(), consdataCreate(), CONSHDLR_NAME, isOverlapping(), NULL, nvars, propagate, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIP_Real, SCIPboundtypeOpposite(), SCIPcreateCons(), SCIPerrorMessage, SCIPfindConshdlr(), SCIPisFinite, separate(), and vars.

Referenced by addLowerboundCons(), adjustOversizedJobBounds(), createConflict(), CUTOFF_CONSTRAINT(), forbidFixation(), presolveSingleLockedVars(), readBounds(), readSemicontinuous(), readVariables(), SCIP_DECL_CONFLICTEXEC(), SCIP_DECL_CONSCOPY(), SCIP_DECL_CONSPARSE(), and SCIPcreateConsBasicBounddisjunction().

SCIPcreateConsBasicBounddisjunction()

SCIP_RETCODE SCIPcreateConsBasicBounddisjunction	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_BOUNDTYPE *	boundtypes,
		SCIP_Real *	bounds )

creates and captures an and constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsBounddisjunction(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h

See also

SCIPcreateConsBounddisjunction() for information about the basic constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

creates and captures a bound disjunction constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsBounddisjunction(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h

See also

SCIPcreateConsBounddisjunction() for information about the basic constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nvars	number of variables in the constraint
vars	variables of the literals in the constraint
boundtypes	types of bounds of the literals (lower or upper bounds)
bounds	bounds of the literals

Definition at line 3400 of file cons_bounddisjunction.c.

References assert(), FALSE, NULL, nvars, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPcreateConsBounddisjunction(), TRUE, and vars.

Referenced by createBounddisjunctionCons(), and SCIPreoptApplyGlbConss().

SCIPcreateConsBounddisjunctionRedundant()

SCIP_RETCODE SCIPcreateConsBounddisjunctionRedundant	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_BOUNDTYPE *	boundtypes,
		SCIP_Real *	bounds,
		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 )

creates and captures a bound disjunction constraint with possibly redundant literals

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nvars	number of variables in the constraint
vars	variables of the literals in the constraint
boundtypes	types of bounds of the literals (lower or upper bounds)
bounds	bounds of the literals
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 3422 of file cons_bounddisjunction.c.

References assert(), consdataCreateRedundant(), CONSHDLR_NAME, NULL, nvars, propagate, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIP_Real, SCIPcreateCons(), SCIPerrorMessage, SCIPfindConshdlr(), separate(), and vars.

Referenced by addLocalConss(), addSplitcons(), and SCIPcreateConsBasicBounddisjunctionRedundant().

SCIPcreateConsBasicBounddisjunctionRedundant()

SCIP_RETCODE SCIPcreateConsBasicBounddisjunctionRedundant	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_BOUNDTYPE *	boundtypes,
		SCIP_Real *	bounds )

creates and captures an and constraint with possibly redundant literals in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsBounddisjunction(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h

See also

SCIPcreateConsBounddisjunction() for information about the basic constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

creates and captures a bound disjunction constraint with possibly redundant literals in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsBounddisjunction(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h

See also

SCIPcreateConsBounddisjunction() for information about the basic constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nvars	number of variables in the constraint
vars	variables of the literals in the constraint
boundtypes	types of bounds of the literals (lower or upper bounds)
bounds	bounds of the literals

Definition at line 3486 of file cons_bounddisjunction.c.

References assert(), FALSE, NULL, nvars, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPcreateConsBounddisjunctionRedundant(), TRUE, and vars.

SCIPgetNVarsBounddisjunction()

int SCIPgetNVarsBounddisjunction	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets number of variables in bound disjunction constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 3505 of file cons_bounddisjunction.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by checkBounddisjunction(), createCoveringProblem(), and SCIP_DECL_CONSCOPY().

SCIPgetVarsBounddisjunction()

SCIP_VAR ** SCIPgetVarsBounddisjunction	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets array of variables in bound disjunction constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 3526 of file cons_bounddisjunction.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by checkBounddisjunction(), createCoveringProblem(), saveConsBounddisjuction(), and SCIP_DECL_CONSCOPY().

SCIPgetBoundtypesBounddisjunction()

SCIP_BOUNDTYPE * SCIPgetBoundtypesBounddisjunction	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets array of bound types in bound disjunction constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 3547 of file cons_bounddisjunction.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by checkBounddisjunction(), saveConsBounddisjuction(), and SCIP_DECL_CONSCOPY().

SCIPgetBoundsBounddisjunction()

SCIP_Real * SCIPgetBoundsBounddisjunction	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets array of bounds in bound disjunction constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 3568 of file cons_bounddisjunction.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_Real, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by checkBounddisjunction(), saveConsBounddisjuction(), and SCIP_DECL_CONSCOPY().

SCIPcreateConsCardinality()

SCIP_RETCODE SCIPcreateConsCardinality	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nvars,
		SCIP_VAR **	vars,
		int	cardval,
		SCIP_VAR **	indvars,
		SCIP_Real *	weights,
		SCIP_Bool	initial,
		SCIP_Bool	separate,
		SCIP_Bool	enforce,
		SCIP_Bool	check,
		SCIP_Bool	propagate,
		SCIP_Bool	local,
		SCIP_Bool	dynamic,
		SCIP_Bool	removable,
		SCIP_Bool	stickingatnode )

creates and captures an cardinality constraint

We set the constraint to not be modifable. If the weights are non NULL, the variables are ordered according to these weights (in ascending order).

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

creates and captures a cardinality constraint

We set the constraint to not be modifable. If the weights are non NULL, the variables are ordered according to these weights (in ascending order).

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nvars	number of variables in the constraint
vars	array with variables of constraint entries
cardval	number of variables allowed to be nonzero
indvars	indicator variables indicating which variables may be treated as nonzero in cardinality constraint, or NULL if new indicator variables should be introduced automatically
weights	weights determining the variable order, or NULL if variables should be ordered in the same way they were added to the constraint
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 3607 of file cons_cardinality.c.

References assert(), CONSHDLR_NAME, FALSE, handleNewVariableCardinality(), NULL, nvars, propagate, SCIP_Bool, SCIP_CALL, SCIP_INVALIDDATA, SCIP_MAXSTRLEN, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIP_Real, SCIP_STAGE_TRANSFORMED, SCIP_VARTYPE_BINARY, SCIPaddVar(), SCIPallocBlockMemory, SCIPallocBlockMemoryArray, SCIPblkmem(), SCIPconshdlrGetData(), SCIPcreateCons(), SCIPcreateVar(), SCIPduplicateBlockMemoryArray, SCIPerrorMessage, SCIPfindConshdlr(), SCIPgetNTotalVars(), SCIPgetStage(), SCIPgetTransformedVar(), SCIPhashmapCreate(), SCIPhashmapExists(), SCIPhashmapGetImage(), SCIPhashmapInsert(), SCIPisFinite, SCIPreleaseVar(), SCIPsnprintf(), SCIPsortRealPtrPtr(), SCIPvarGetName(), SCIPvarIsBinary(), SCIPvarIsTransformed(), separate(), var, and vars.

Referenced by branchBalancedCardinality(), SCIP_DECL_CONSCOPY(), SCIP_DECL_CONSPARSE(), SCIP_DECL_CONSPRESOL(), and SCIPcreateConsBasicCardinality().

SCIPcreateConsBasicCardinality()

SCIP_RETCODE SCIPcreateConsBasicCardinality	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nvars,
		SCIP_VAR **	vars,
		int	cardval,
		SCIP_VAR **	indvars,
		SCIP_Real *	weights )

creates and captures an cardinality constraint in its most basic variant, i. e., with all constraint flags set to their default values, which can be set afterwards using SCIPsetConsFLAGNAME() in scip.h

See also

SCIPcreateConsCardinality() for the default constraint flag configuration

Warning

Do NOT set the constraint to be modifiable manually, because this might lead to wrong results as the variable array will not be re-sorted

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

creates and captures a cardinality constraint with all constraint flags set to their default values.

Warning

Do NOT set the constraint to be modifiable manually, because this might lead to wrong results as the variable array will not be re-sorted

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nvars	number of variables in the constraint
vars	array with variables of constraint entries
cardval	number of variables allowed to be nonzero
indvars	indicator variables indicating which variables may be treated as nonzero in cardinality constraint, or NULL if new indicator variables should be introduced automatically
weights	weights determining the variable order, or NULL if variables should be ordered in the same way they were added to the constraint

Definition at line 3819 of file cons_cardinality.c.

References FALSE, nvars, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPcreateConsCardinality(), TRUE, and vars.

SCIPchgCardvalCardinality()

SCIP_RETCODE SCIPchgCardvalCardinality	(	SCIP *	scip,
		SCIP_CONS *	cons,
		int	cardval )

changes cardinality value of cardinality constraint (i.e., right hand side of cardinality constraint)

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
cardval	number of variables allowed to be nonzero

Definition at line 3840 of file cons_cardinality.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_INVALIDDATA, SCIP_OKAY, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPdebugMsg, and SCIPerrorMessage.

Referenced by SCIP_DECL_CONSPARSE().

SCIPaddVarCardinality()

SCIP_RETCODE SCIPaddVarCardinality	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var,
		SCIP_VAR *	indvar,
		SCIP_Real	weight )

adds variable to cardinality constraint, the position is determined by the given weight

Parameters

scip	SCIP data structure
cons	constraint
var	variable to add to the constraint
indvar	indicator variable indicating whether variable may be treated as nonzero in cardinality constraint (or NULL if this variable should be created automatically)
weight	weight determining position of variable

Definition at line 3869 of file cons_cardinality.c.

References addVarCardinality(), assert(), CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_Real, SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconshdlrGetData(), SCIPconshdlrGetName(), SCIPdebugMsg, SCIPerrorMessage, SCIPvarGetName(), and var.

Referenced by SCIP_DECL_CONSPARSE().

SCIPappendVarCardinality()

SCIP_RETCODE SCIPappendVarCardinality	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var,
		SCIP_VAR *	indvar )

appends variable to cardinality constraint

Parameters

scip	SCIP data structure
cons	constraint
var	variable to add to the constraint
indvar	indicator variable indicating whether variable may be treated as nonzero in cardinality constraint (or NULL if this variable should be created automatically)

Definition at line 3906 of file cons_cardinality.c.

References appendVarCardinality(), assert(), CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconshdlrGetData(), SCIPconshdlrGetName(), SCIPdebugMsg, SCIPerrorMessage, SCIPvarGetName(), and var.

SCIPgetNVarsCardinality()

int SCIPgetNVarsCardinality	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets number of variables in cardinality constraint

Parameters

scip	SCIP data structure
cons	constraint

Definition at line 3941 of file cons_cardinality.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

SCIPgetVarsCardinality()

SCIP_VAR ** SCIPgetVarsCardinality	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets array of variables in cardinality constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 3965 of file cons_cardinality.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

SCIPgetCardvalCardinality()

int SCIPgetCardvalCardinality	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets cardinality value of cardinality constraint (i.e., right hand side of cardinality constraint)

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 3989 of file cons_cardinality.c.

References assert(), CONSHDLR_NAME, NULL, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

SCIPgetWeightsCardinality()

SCIP_Real * SCIPgetWeightsCardinality	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets array of weights in cardinality constraint (or NULL if not existent)

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 4012 of file cons_cardinality.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_Real, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

SCIPcreateConsConjunction()

SCIP_RETCODE SCIPcreateConsConjunction	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nconss,
		SCIP_CONS **	conss,
		SCIP_Bool	enforce,
		SCIP_Bool	check,
		SCIP_Bool	local,
		SCIP_Bool	modifiable,
		SCIP_Bool	dynamic )

creates and captures a conjunction constraint

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nconss	number of initial constraints in conjunction
conss	initial constraint in conjunction
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.

Definition at line 808 of file cons_conjunction.c.

References consdataCreate(), CONSHDLR_NAME, FALSE, NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIPcreateCons(), SCIPerrorMessage, and SCIPfindConshdlr().

Referenced by SCIP_DECL_CONSCOPY(), SCIP_DECL_CONSPARSE(), and SCIPcreateConsBasicConjunction().

SCIPcreateConsBasicConjunction()

SCIP_RETCODE SCIPcreateConsBasicConjunction	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nconss,
		SCIP_CONS **	conss )

creates and captures an and constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsConjunction(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h

See also

SCIPcreateConsConjunction() for information about the basic constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nconss	number of initial constraints in conjunction
conss	initial constraint in conjunction

Definition at line 857 of file cons_conjunction.c.

References assert(), FALSE, NULL, SCIP_CALL, SCIP_OKAY, SCIPcreateConsConjunction(), and TRUE.

SCIPaddConsElemConjunction()

SCIP_RETCODE SCIPaddConsElemConjunction	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_CONS *	addcons )

adds constraint to the conjunction of constraints

Parameters

scip	SCIP data structure
cons	conjunction constraint
addcons	additional constraint in conjunction

Definition at line 874 of file cons_conjunction.c.

References assert(), consdataAddCons(), CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

SCIP_DECL_DIALOGEXEC() [1/4]

SCIP_DECL_DIALOGEXEC

(

SCIPdialogExecCountPresolve

)

dialog execution method for the count command

Definition at line 1842 of file cons_countsols.c.

References active, CONSHDLR_NAME, FALSE, NULL, SCIP_Bool, SCIP_CALL, SCIP_INVALIDCALL, SCIP_OKAY, SCIP_STAGE_EXITPRESOLVE, SCIP_STAGE_EXITSOLVE, SCIP_STAGE_FREE, SCIP_STAGE_FREETRANS, SCIP_STAGE_INIT, SCIP_STAGE_INITPRESOLVE, SCIP_STAGE_INITSOLVE, SCIP_STAGE_PRESOLVED, SCIP_STAGE_PRESOLVING, SCIP_STAGE_PROBLEM, SCIP_STAGE_SOLVED, SCIP_STAGE_SOLVING, SCIP_STAGE_TRANSFORMED, SCIP_STAGE_TRANSFORMING, SCIPdialoghdlrAddHistory(), SCIPdialoghdlrGetRoot(), SCIPdialogMessage(), SCIPerrorMessage, SCIPgetBoolParam(), SCIPgetIntParam(), SCIPgetStage(), SCIPpresolve(), SCIPsetBoolParam(), SCIPsetIntParam(), SCIPwarningMessage(), SYM_HANDLETYPE_SYMCONS, SYM_TIMING_AFTERPRESOL, and TRUE.

SCIP_DECL_DIALOGEXEC() [2/4]

SCIP_DECL_DIALOGEXEC

(

SCIPdialogExecCount

)

dialog execution method for the count command

Definition at line 1935 of file cons_countsols.c.

References active, assert(), CONSHDLR_NAME, FALSE, NULL, SCIP_Bool, SCIP_CALL, SCIP_INVALIDCALL, SCIP_Longint, SCIP_LONGINT_FORMAT, SCIP_MAXSTRLEN, SCIP_OKAY, SCIP_STAGE_EXITPRESOLVE, SCIP_STAGE_EXITSOLVE, SCIP_STAGE_FREE, SCIP_STAGE_FREETRANS, SCIP_STAGE_INIT, SCIP_STAGE_INITPRESOLVE, SCIP_STAGE_INITSOLVE, SCIP_STAGE_PRESOLVED, SCIP_STAGE_PRESOLVING, SCIP_STAGE_PROBLEM, SCIP_STAGE_SOLVED, SCIP_STAGE_SOLVING, SCIP_STAGE_TRANSFORMED, SCIP_STAGE_TRANSFORMING, SCIP_VERBLEVEL_FULL, SCIPallocBufferArray, SCIPcount(), SCIPdialoghdlrAddHistory(), SCIPdialoghdlrGetRoot(), SCIPdialogMessage(), SCIPerrorMessage, SCIPfindConshdlr(), SCIPfreeBufferArray, SCIPgetBoolParam(), SCIPgetIntParam(), SCIPgetNContVars(), SCIPgetNCountedFeasSubtrees(), SCIPgetNCountedSols(), SCIPgetNCountedSolsstr(), SCIPgetStage(), SCIPisParamFixed(), SCIPpresolve(), SCIPreallocBufferArray, SCIPsetBoolParam(), SCIPsetIntParam(), SCIPunfixParam(), SCIPverbMessage(), SCIPwarningMessage(), SYM_HANDLETYPE_SYMCONS, SYM_TIMING_AFTERPRESOL, TRUE, and valid.

SCIP_DECL_DIALOGEXEC() [3/4]

SCIP_DECL_DIALOGEXEC

(

SCIPdialogExecWriteAllsolutions

)

execution method of dialog for writing all solutions

Definition at line 2279 of file cons_countsols.c.

References assert(), CONSHDLR_NAME, FALSE, NULL, nvars, SCIP_Bool, SCIP_CALL, SCIP_ERROR, SCIP_Longint, SCIP_LONGINT_FORMAT, SCIP_MAXSTRLEN, SCIP_OKAY, SCIP_STAGE_EXITPRESOLVE, SCIP_STAGE_EXITSOLVE, SCIP_STAGE_FREE, SCIP_STAGE_FREETRANS, SCIP_STAGE_INIT, SCIP_STAGE_INITPRESOLVE, SCIP_STAGE_INITSOLVE, SCIP_STAGE_PRESOLVED, SCIP_STAGE_PRESOLVING, SCIP_STAGE_PROBLEM, SCIP_STAGE_SOLVED, SCIP_STAGE_SOLVING, SCIP_STAGE_TRANSFORMED, SCIP_STAGE_TRANSFORMING, SCIPallocBufferArray, SCIPconshdlrGetData(), SCIPdialoghdlrAddHistory(), SCIPdialoghdlrClearBuffer(), SCIPdialoghdlrGetRoot(), SCIPdialoghdlrGetWord(), SCIPdialogMessage(), SCIPduplicateBufferArray, SCIPerrorMessage, SCIPfindConshdlr(), SCIPfreeBufferArray, SCIPgetNCountedSols(), SCIPgetNCountedSolsstr(), SCIPgetNOrigVars(), SCIPgetOrigVars(), SCIPgetStage(), SCIPgetTransformedVar(), SCIPinfoMessage(), SCIPreallocBufferArray, SCIPsortDownPtrPtr(), SCIPvarGetName(), SCIPvarIsIntegral(), TRUE, valid, and writeExpandedSolutions().

SCIPcount()

SCIP_RETCODE SCIPcount

(

SCIP *

scip

)

execute counting

Parameters

scip	SCIP data structure

Definition at line 2701 of file cons_countsols.c.

References active, checkParameters(), CONSHDLR_NAME, FALSE, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIPgetBoolParam(), SCIPsetBoolParam(), SCIPsolve(), and TRUE.

Referenced by SCIP_DECL_DIALOGEXEC().

SCIPgetNCountedSols()

SCIP_Longint SCIPgetNCountedSols	(	SCIP *	scip,
		SCIP_Bool *	valid )

returns number of feasible solutions found as SCIP_Longint; if the number does not fit into a SCIP_Longint the valid flag is set to FALSE

Parameters

scip	SCIP data structure
valid	pointer to store if the return value is valid

Definition at line 2733 of file cons_countsols.c.

References assert(), CONSHDLR_NAME, getNCountedSols(), NULL, SCIP_Bool, SCIP_Longint, SCIPconshdlrGetData(), SCIPfindConshdlr(), and valid.

Referenced by SCIP_DECL_DIALOGEXEC(), SCIP_DECL_DIALOGEXEC(), and SCIP_DECL_DISPOUTPUT().

SCIPgetNCountedSolsstr()

void SCIPgetNCountedSolsstr	(	SCIP *	scip,
		char **	buffer,
		int	buffersize,
		int *	requiredsize )

returns number of counted solutions as string

puts the number of counted solutions in the given char* buffer

Parameters

scip	SCIP data structure
buffer	buffer to store the number for counted solutions
buffersize	buffer size
requiredsize	pointer to store the required size

Definition at line 2753 of file cons_countsols.c.

References assert(), CONSHDLR_NAME, NULL, SCIPconshdlrGetData(), SCIPfindConshdlr(), and toString().

Referenced by SCIP_DECL_DIALOGEXEC(), and SCIP_DECL_DIALOGEXEC().

SCIPgetNCountedFeasSubtrees()

SCIP_Longint SCIPgetNCountedFeasSubtrees

(

SCIP *

scip

)

returns number of counted feasible subtrees

returns number of counted non trivial feasible subtrees

Parameters

scip	SCIP data structure

Definition at line 2791 of file cons_countsols.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_Longint, SCIPconshdlrGetData(), and SCIPfindConshdlr().

Referenced by SCIP_DECL_DIALOGEXEC(), and SCIP_DECL_DISPOUTPUT().

SCIPgetCountedSparseSols()

void SCIPgetCountedSparseSols	(	SCIP *	scip,
		SCIP_VAR ***	vars,
		int *	nvars,
		SCIP_SPARSESOL ***	sols,
		int *	nsols )

Method to get the sparse solution.

Note

You get the pointer to the sparse solutions stored in the constraint handler (not a copy).

The sparse solutions are stored w.r.t. the active variables. This are the variables which got not removed during presolving. For none active variables the value has to be computed depending on their aggregation type. See for more details about that Collect all feasible solutions.

Method to get the sparse solution.

Note

You get the pointer to the sparse solutions stored in the constraint handler (not a copy).

The sparse solutions are stored w.r.t. the active variables. There are the variables which have not been removed during presolving. For none active variables the value has to be computed depending on their aggregation type. See for more details about that Collect all feasible solutions.

Parameters

scip	SCIP data structure
vars	pointer to active variable array defining to variable order
nvars	number of active variables
sols	pointer to the solutions
nsols	pointer to number of solutions

Definition at line 2819 of file cons_countsols.c.

References assert(), CONSHDLR_NAME, NULL, nvars, SCIPconshdlrGetData(), SCIPfindConshdlr(), and vars.

SCIPsetParamsCountsols()

SCIP_RETCODE SCIPsetParamsCountsols

(

SCIP *

scip

)

setting SCIP parameters for such that a valid counting process is possible

Parameters

scip	SCIP data structure

Definition at line 2846 of file cons_countsols.c.

References SCIP_CALL, SCIP_OKAY, SCIP_PARAMEMPHASIS_COUNTER, SCIPsetEmphasis(), and TRUE.

SCIPcreateConsCumulative()

SCIP_RETCODE SCIPcreateConsCumulative	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nvars,
		SCIP_VAR **	vars,
		int *	durations,
		int *	demands,
		int	capacity,
		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 )

creates and captures a cumulative constraint

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nvars	number of variables (jobs)
vars	array of integer variable which corresponds to starting times for a job
durations	array containing corresponding durations
demands	array containing corresponding demands
capacity	available cumulative capacity
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are seperated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 13641 of file cons_cumulative.c.

References assert(), boundedConvertRealToInt(), consdataCatchEvents(), consdataCreate(), CONSHDLR_NAME, i, NULL, nvars, propagate, SCIP_Bool, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIP_STAGE_PROBLEM, SCIPconshdlrGetData(), SCIPcreateCons(), SCIPdebugMsg, SCIPerrorMessage, SCIPfindConshdlr(), SCIPgetStage(), SCIPvarGetName(), SCIPvarGetUbGlobal(), separate(), and vars.

Referenced by CREATE_CONSTRAINT(), createConsCumulative(), createCumulativeCons(), SCIP_DECL_CONSCOPY(), SCIP_DECL_CONSPARSE(), SCIPcreateConsBasicCumulative(), SCIPcreateSchedulingProblem(), and upgradeCons().

SCIPcreateConsBasicCumulative()

SCIP_RETCODE SCIPcreateConsBasicCumulative	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nvars,
		SCIP_VAR **	vars,
		int *	durations,
		int *	demands,
		int	capacity )

creates and captures an absolute power constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsCumulative(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h

See also

SCIPcreateConsCumulative() for information about the basic constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

creates and captures a cumulative constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsCumulative(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h

See also

SCIPcreateConsCumulative() for information about the basic constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nvars	number of variables (jobs)
vars	array of integer variable which corresponds to starting times for a job
durations	array containing corresponding durations
demands	array containing corresponding demands
capacity	available cumulative capacity

Definition at line 13733 of file cons_cumulative.c.

References assert(), FALSE, NULL, nvars, SCIP_CALL, SCIP_OKAY, SCIPcreateConsCumulative(), TRUE, and vars.

Referenced by setupAndSolveCumulativeSubscip().

SCIPsetHminCumulative()

SCIP_RETCODE SCIPsetHminCumulative	(	SCIP *	scip,
		SCIP_CONS *	cons,
		int	hmin )

set the left bound of effective horizon

set the left bound of the time axis to be considered (including hmin)

Parameters

scip	SCIP data structure
cons	constraint data
hmin	left bound of time axis to be considered

Definition at line 13753 of file cons_cumulative.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_INVALIDCALL, SCIP_OKAY, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by createConsCumulative(), SCIP_DECL_CONSCOPY(), SCIP_DECL_CONSPARSE(), setupAndSolveCumulativeSubscip(), and upgradeCons().

SCIPgetHminCumulative()

int SCIPgetHminCumulative	(	SCIP *	scip,
		SCIP_CONS *	cons )

returns the left bound of the effective horizon

returns the left bound of the time axis to be considered

Parameters

scip	SCIP data structure
cons	constraint

Definition at line 13782 of file cons_cumulative.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by SCIP_DECL_CONSRESPROP().

SCIPsetHmaxCumulative()

SCIP_RETCODE SCIPsetHmaxCumulative	(	SCIP *	scip,
		SCIP_CONS *	cons,
		int	hmax )

set the right bound of the effective horizon

set the right bound of the time axis to be considered (not including hmax)

Parameters

scip	SCIP data structure
cons	constraint data
hmax	right bound of time axis to be considered

Definition at line 13802 of file cons_cumulative.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_INVALIDCALL, SCIP_OKAY, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by createConsCumulative(), SCIP_DECL_CONSCOPY(), SCIP_DECL_CONSPARSE(), setupAndSolveCumulativeSubscip(), and upgradeCons().

SCIPgetHmaxCumulative()

int SCIPgetHmaxCumulative	(	SCIP *	scip,
		SCIP_CONS *	cons )

returns the right bound of effective horizon

returns the right bound of the time axis to be considered

Parameters

scip	SCIP data structure
cons	constraint

Definition at line 13832 of file cons_cumulative.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by SCIP_DECL_CONSRESPROP().

SCIPgetVarsCumulative()

SCIP_VAR ** SCIPgetVarsCumulative	(	SCIP *	scip,
		SCIP_CONS *	cons )

returns the start time variables of the cumulative constraint

returns the activities of the cumulative constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 13852 of file cons_cumulative.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by writeFzn().

SCIPgetNVarsCumulative()

int SCIPgetNVarsCumulative	(	SCIP *	scip,
		SCIP_CONS *	cons )

returns the number of start time variables of the cumulative constraint

returns the activities of the cumulative constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 13873 of file cons_cumulative.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by writeFzn().

SCIPgetCapacityCumulative()

int SCIPgetCapacityCumulative	(	SCIP *	scip,
		SCIP_CONS *	cons )

returns the capacity of the cumulative constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 13894 of file cons_cumulative.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by writeFzn().

SCIPgetDurationsCumulative()

int * SCIPgetDurationsCumulative	(	SCIP *	scip,
		SCIP_CONS *	cons )

returns the durations of the cumulative constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 13915 of file cons_cumulative.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by writeFzn().

SCIPgetDemandsCumulative()

int * SCIPgetDemandsCumulative	(	SCIP *	scip,
		SCIP_CONS *	cons )

returns the demands of the cumulative constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 13936 of file cons_cumulative.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by writeFzn().

SCIPcheckCumulativeCondition()

SCIP_RETCODE SCIPcheckCumulativeCondition	(	SCIP *	scip,
		SCIP_SOL *	sol,
		int	nvars,
		SCIP_VAR **	vars,
		int *	durations,
		int *	demands,
		int	capacity,
		int	hmin,
		int	hmax,
		SCIP_Bool *	violated,
		SCIP_CONS *	cons,
		SCIP_Bool	printreason )

check for the given starting time variables with their demands and durations if the cumulative conditions for the given solution is satisfied

Parameters

scip	SCIP data structure
sol	primal solution, or NULL for current LP/pseudo solution
nvars	number of variables (jobs)
vars	array of integer variable which corresponds to starting times for a job
durations	array containing corresponding durations
demands	array containing corresponding demands
capacity	available cumulative capacity
hmin	left bound of time axis to be considered (including hmin)
hmax	right bound of time axis to be considered (not including hmax)
violated	pointer to store if the cumulative condition is violated
cons	constraint which is checked
printreason	should the reason for the violation be printed?

Definition at line 13959 of file cons_cumulative.c.

References assert(), checkCumulativeCondition(), NULL, nvars, SCIP_Bool, SCIP_CALL, SCIP_OKAY, sol, and vars.

Referenced by checkCons(), and enfopsCons().

SCIPnormalizeCumulativeCondition()

SCIP_RETCODE SCIPnormalizeCumulativeCondition	(	SCIP *	scip,
		int	nvars,
		SCIP_VAR **	vars,
		int *	durations,
		int *	demands,
		int *	capacity,
		int *	nchgcoefs,
		int *	nchgsides )

normalize cumulative condition

Parameters

scip	SCIP data structure
nvars	number of start time variables (activities)
vars	array of start time variables
durations	array of durations
demands	array of demands
capacity	pointer to store the changed cumulative capacity
nchgcoefs	pointer to count total number of changed coefficients
nchgsides	pointer to count number of side changes

Definition at line 13984 of file cons_cumulative.c.

References normalizeCumulativeCondition(), nvars, SCIP_OKAY, and vars.

Referenced by SCIP_DECL_CONSPRESOL().

SCIPsplitCumulativeCondition()

SCIP_RETCODE SCIPsplitCumulativeCondition	(	SCIP *	scip,
		int	nvars,
		SCIP_VAR **	vars,
		int *	durations,
		int *	demands,
		int	capacity,
		int *	hmin,
		int *	hmax,
		int *	split )

searches for a time point within the cumulative condition were the cumulative condition can be split

Parameters

scip	SCIP data structure
nvars	number of variables (jobs)
vars	array of integer variable which corresponds to starting times for a job
durations	array containing corresponding durations
demands	array containing corresponding demands
capacity	available cumulative capacity
hmin	pointer to store the left bound of the effective horizon
hmax	pointer to store the right bound of the effective horizon
split	point were the cumulative condition can be split

Definition at line 14001 of file cons_cumulative.c.

References computeEffectiveHorizonCumulativeCondition(), nvars, SCIP_CALL, SCIP_OKAY, and vars.

Referenced by SCIP_DECL_CONSPRESOL().

SCIPpresolveCumulativeCondition()

SCIP_RETCODE SCIPpresolveCumulativeCondition	(	SCIP *	scip,
		int	nvars,
		SCIP_VAR **	vars,
		int *	durations,
		int	hmin,
		int	hmax,
		SCIP_Bool *	downlocks,
		SCIP_Bool *	uplocks,
		SCIP_CONS *	cons,
		SCIP_Bool *	irrelevants,
		int *	nfixedvars,
		int *	nchgsides,
		SCIP_Bool *	cutoff )

presolve cumulative condition w.r.t. effective horizon by detecting irrelevant variables

Parameters

scip	SCIP data structure
nvars	number of start time variables (activities)
vars	array of start time variables
durations	array of durations
hmin	left bound of time axis to be considered
hmax	right bound of time axis to be considered (not including hmax)
downlocks	array storing if the variable has a down lock, or NULL
uplocks	array storing if the variable has an up lock, or NULL
cons	constraint which gets propagated, or NULL
irrelevants	array mark those variables which are irrelevant for the cumulative condition
nfixedvars	pointer to store the number of fixed variables
nchgsides	pointer to store the number of changed sides
cutoff	buffer to store whether a cutoff is detected

Definition at line 14020 of file cons_cumulative.c.

References cutoff, nvars, presolveConsEst(), presolveConsLct(), SCIP_Bool, SCIP_CALL, SCIP_OKAY, and vars.

Referenced by presolveCumulativeCondition().

SCIPpropCumulativeCondition()

SCIP_RETCODE SCIPpropCumulativeCondition	(	SCIP *	scip,
		SCIP_PRESOLTIMING	presoltiming,
		int	nvars,
		SCIP_VAR **	vars,
		int *	durations,
		int *	demands,
		int	capacity,
		int	hmin,
		int	hmax,
		SCIP_CONS *	cons,
		int *	nchgbds,
		SCIP_Bool *	initialized,
		SCIP_Bool *	explanation,
		SCIP_Bool *	cutoff )

propagate the given cumulative condition

Parameters

scip	SCIP data structure
presoltiming	current presolving timing
nvars	number of variables (jobs)
vars	array of integer variable which corresponds to starting times for a job
durations	array containing corresponding durations
demands	array containing corresponding demands
capacity	available cumulative capacity
hmin	left bound of time axis to be considered (including hmin)
hmax	right bound of time axis to be considered (not including hmax)
cons	constraint which gets propagated
nchgbds	pointer to store the number of variable bound changes
initialized	was conflict analysis initialized
explanation	bool array which marks the variable which are part of the explanation if a cutoff was detected, or NULL
cutoff	pointer to store if the cumulative condition is violated

Definition at line 14051 of file cons_cumulative.c.

References assert(), CONSHDLR_NAME, cutoff, FALSE, NULL, nvars, propagateCumulativeCondition(), SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIPconshdlrGetData(), SCIPerrorMessage, SCIPfindConshdlr(), and vars.

Referenced by propagateCons().

SCIPrespropCumulativeCondition()

SCIP_RETCODE SCIPrespropCumulativeCondition	(	SCIP *	scip,
		int	nvars,
		SCIP_VAR **	vars,
		int *	durations,
		int *	demands,
		int	capacity,
		int	hmin,
		int	hmax,
		SCIP_VAR *	infervar,
		int	inferinfo,
		SCIP_BOUNDTYPE	boundtype,
		SCIP_BDCHGIDX *	bdchgidx,
		SCIP_Real	relaxedbd,
		SCIP_Bool *	explanation,
		SCIP_RESULT *	result )

resolve propagation w.r.t. the cumulative condition

Parameters

scip	SCIP data structure
nvars	number of start time variables (activities)
vars	array of start time variables
durations	array of durations
demands	array of demands
capacity	cumulative capacity
hmin	left bound of time axis to be considered (including hmin)
hmax	right bound of time axis to be considered (not including hmax)
infervar	the conflict variable whose bound change has to be resolved
inferinfo	the user information
boundtype	the type of the changed bound (lower or upper bound)
bdchgidx	the index of the bound change, representing the point of time where the change took place
relaxedbd	the relaxed bound which is sufficient to be explained
explanation	bool array which marks the variable which are part of the explanation if a cutoff was detected, or NULL
result	pointer to store the result of the propagation conflict resolving call

Definition at line 14100 of file cons_cumulative.c.

References intToInferInfo(), nvars, respropCumulativeCondition(), result, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_Real, TRUE, and vars.

Referenced by SCIP_DECL_CONSRESPROP().

SCIPvisualizeConsCumulative()

SCIP_RETCODE SCIPvisualizeConsCumulative	(	SCIP *	scip,
		SCIP_CONS *	cons )

this method visualizes the cumulative structure in GML format

Parameters

scip	SCIP data structure
cons	cumulative constraint

Definition at line 14125 of file cons_cumulative.c.

References assert(), b, NULL, nvars, SCIP_CALL_TERMINATE, SCIP_FILECREATEERROR, SCIP_MAXSTRLEN, SCIP_OKAY, SCIPblkmem(), SCIPconsGetData(), SCIPconsGetName(), SCIPerrorMessage, SCIPgmlWriteArc(), SCIPgmlWriteClosing(), SCIPgmlWriteNode(), SCIPgmlWriteOpening(), SCIPhashtableCreate(), SCIPhashtableExists(), SCIPhashtableFree(), SCIPhashtableInsert(), SCIPprintSysError(), SCIPsnprintf(), SCIPvarGetLbGlobal(), SCIPvarGetName(), SCIPvarGetNVlbs(), SCIPvarGetNVubs(), SCIPvarGetUbGlobal(), SCIPvarGetVlbVars(), SCIPvarGetVubVars(), TRUE, var, and vars.

SCIPsetSolveCumulative()

SCIP_RETCODE SCIPsetSolveCumulative

(

SCIP *

scip

)

sets method to solve an individual cumulative condition

Parameters

scip	SCIP data structure method to use an individual cumulative condition

Definition at line 14229 of file cons_cumulative.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIPconshdlrGetData(), SCIPerrorMessage, SCIPfindConshdlr(), and solveCumulative().

Referenced by runShell().

SCIPsolveCumulative()

SCIP_RETCODE SCIPsolveCumulative	(	SCIP *	scip,
		int	njobs,
		SCIP_Real *	ests,
		SCIP_Real *	lsts,
		SCIP_Real *	objvals,
		int *	durations,
		int *	demands,
		int	capacity,
		int	hmin,
		int	hmax,
		SCIP_Real	timelimit,
		SCIP_Real	memorylimit,
		SCIP_Longint	maxnodes,
		SCIP_Bool *	solved,
		SCIP_Bool *	infeasible,
		SCIP_Bool *	unbounded,
		SCIP_Bool *	error )

solves given cumulative condition as independent sub problem

Note

If the problem was solved to the earliest start times (ests) and latest start times (lsts) array contain the solution values; If the problem was not solved these two arrays contain the global bounds at the time the sub solver was interrupted.

Parameters

scip	SCIP data structure
njobs	number of jobs (activities)
ests	array with the earlier start time for each job
lsts	array with the latest start time for each job
objvals	array of objective coefficients for each job (linear objective function), or NULL if none
durations	array of durations
demands	array of demands
capacity	cumulative capacity
hmin	left bound of time axis to be considered (including hmin)
hmax	right bound of time axis to be considered (not including hmax)
timelimit	time limit for solving in seconds
memorylimit	memory limit for solving in mega bytes (MB)
maxnodes	maximum number of branch-and-bound nodes to solve the single cumulative constraint (-1: no limit)
solved	pointer to store if the problem is solved (to optimality)
infeasible	pointer to store if the problem is infeasible
unbounded	pointer to store if the problem is unbounded
error	pointer to store if an error occurred

Definition at line 14259 of file cons_cumulative.c.

References assert(), CONSHDLR_NAME, FALSE, NULL, SCIP_Bool, SCIP_CALL, SCIP_Longint, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIP_Real, SCIPconshdlrGetData(), SCIPerrorMessage, SCIPfindConshdlr(), and TRUE.

Referenced by applyOptcumulative(), solveCumulative(), and solveIndependentCons().

SCIPcreateWorstCaseProfile()

SCIP_RETCODE SCIPcreateWorstCaseProfile	(	SCIP *	scip,
		SCIP_PROFILE *	profile,
		int	nvars,
		SCIP_VAR **	vars,
		int *	durations,
		int *	demands )

creates the worst case resource profile, that is, all jobs are inserted with the earliest start and latest completion time

Parameters

scip	SCIP data structure
profile	resource profile
nvars	number of variables (jobs)
vars	array of integer variable which corresponds to starting times for a job
durations	array containing corresponding durations
demands	array containing corresponding demands

Definition at line 14315 of file cons_cumulative.c.

References assert(), boundedConvertRealToInt(), computeImpliedEst(), computeImpliedLct(), NULL, nvars, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIPallocBufferArray, SCIPblkmem(), SCIPfreeBufferArray, SCIPhashmapCreate(), SCIPhashmapFree(), SCIPhashmapInsertInt(), SCIPprofileInsertCore(), SCIPsortDownIntInt(), SCIPvarGetLbLocal(), SCIPvarGetUbLocal(), var, and vars.

Referenced by computeAlternativeBounds(), computeEffectiveHorizonCumulativeCondition(), and propagateCons().

SCIPcomputeHmin()

int SCIPcomputeHmin	(	SCIP *	scip,
		SCIP_PROFILE *	profile,
		int	capacity )

computes w.r.t. the given worst case resource profile the first time point where the given capacity can be violated

Parameters

scip	SCIP data structure
profile	worst case resource profile
capacity	capacity to check

Definition at line 14394 of file cons_cumulative.c.

References assert(), SCIPprofileGetLoads(), SCIPprofileGetNTimepoints(), and SCIPprofileGetTimepoints().

Referenced by computeAlternativeBounds(), computeEffectiveHorizonCumulativeCondition(), and propagateCons().

SCIPcomputeHmax()

int SCIPcomputeHmax	(	SCIP *	scip,
		SCIP_PROFILE *	profile,
		int	capacity )

computes w.r.t. the given worst case resource profile the first time point where the given capacity is satisfied for sure

Parameters

scip	SCIP data structure
profile	worst case profile
capacity	capacity to check

Definition at line 14424 of file cons_cumulative.c.

References assert(), SCIPprofileGetLoads(), SCIPprofileGetNTimepoints(), and SCIPprofileGetTimepoints().

Referenced by computeAlternativeBounds(), and computeEffectiveHorizonCumulativeCondition().

SCIPcreateConsDisjunction()

SCIP_RETCODE SCIPcreateConsDisjunction	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nconss,
		SCIP_CONS **	conss,
		SCIP_CONS *	relaxcons,
		SCIP_Bool	initial,
		SCIP_Bool	enforce,
		SCIP_Bool	check,
		SCIP_Bool	local,
		SCIP_Bool	modifiable,
		SCIP_Bool	dynamic )

creates and captures a disjunction constraint

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nconss	number of initial constraints in disjunction
conss	initial constraint in disjunction
relaxcons	a conjunction constraint containing the linear relaxation of the disjunction constraint, or NULL
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.

Definition at line 1200 of file cons_disjunction.c.

References consdataCreate(), CONSHDLR_NAME, FALSE, NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIPcreateCons(), SCIPerrorMessage, and SCIPfindConshdlr().

Referenced by SCIP_DECL_CONSCOPY(), SCIP_DECL_CONSPARSE(), and SCIPcreateConsBasicDisjunction().

SCIPcreateConsBasicDisjunction()

SCIP_RETCODE SCIPcreateConsBasicDisjunction	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nconss,
		SCIP_CONS **	conss,
		SCIP_CONS *	relaxcons )

creates and captures a cumulative constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsDisjunction(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h

See also

SCIPcreateConsDisjunction() for information about the basic constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nconss	number of initial constraints in disjunction
conss	initial constraint in disjunction
relaxcons	a conjunction constraint containing the linear relaxation of the disjunction constraint, or NULL

Definition at line 1252 of file cons_disjunction.c.

References assert(), FALSE, NULL, SCIP_CALL, SCIP_OKAY, SCIPcreateConsDisjunction(), and TRUE.

SCIPaddConsElemDisjunction()

SCIP_RETCODE SCIPaddConsElemDisjunction	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_CONS *	addcons )

adds constraint to the disjunction of constraints

Parameters

scip	SCIP data structure
cons	disjunction constraint
addcons	additional constraint in disjunction

Definition at line 1271 of file cons_disjunction.c.

References assert(), consdataAddCons(), CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

SCIPcreateConsExactLinear()

SCIP_RETCODE SCIPcreateConsExactLinear	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_RATIONAL **	vals,
		SCIP_RATIONAL *	lhs,
		SCIP_RATIONAL *	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 )

creates and captures a linear constraint

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nvars	number of nonzeros in the constraint
vars	array with variables of constraint entries
vals	array with coefficients of constraint entries
lhs	left hand side of constraint
rhs	right hand side of constraint
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 6624 of file cons_exactlinear.c.

References assert(), consdataCreate(), CONSHDLR_NAME, i, NULL, nvars, propagate, SCIP_Bool, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIP_STAGE_EXITPRESOLVE, SCIPABORT, SCIPbuffer(), SCIPcreateCons(), SCIPduplicateBufferArray, SCIPerrorMessage, SCIPfindConshdlr(), SCIPfreeBufferArray, SCIPgetProbvarLinearSumExact(), SCIPgetStage(), SCIPrationalCreateBuffer(), SCIPrationalDiff(), SCIPrationalFreeBuffer(), SCIPrationalIsAbsInfinity(), SCIPreallocBufferArray, SCIPvarGetName(), separate(), TRUE, and vars.

Referenced by createAndAddProofcons(), getFixedVariable(), readConstraints(), readConstraintsRational(), readOPBFile(), readRowsExact(), SCIP_DECL_CONSPARSE(), and SCIPcreateConsBasicExactLinear().

SCIPcreateConsBasicExactLinear()

SCIP_RETCODE SCIPcreateConsBasicExactLinear	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_RATIONAL **	vals,
		SCIP_RATIONAL *	lhs,
		SCIP_RATIONAL *	rhs )

creates and captures a linear constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsLinear(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h

See also

SCIPcreateConsLinear() for information about the basic constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nvars	number of nonzeros in the constraint
vars	array with variables of constraint entries
vals	array with coefficients of constraint entries
lhs	left hand side of constraint
rhs	right hand side of constraint

Definition at line 6762 of file cons_exactlinear.c.

References assert(), FALSE, NULL, nvars, SCIP_CALL, SCIP_OKAY, SCIPcreateConsExactLinear(), TRUE, and vars.

SCIPcopyConsExactLinear()

SCIP_RETCODE SCIPcopyConsExactLinear	(	SCIP *	scip,
		SCIP_CONS **	cons,
		SCIP *	sourcescip,
		const char *	name,
		int	nvars,
		SCIP_VAR **	sourcevars,
		SCIP_INTERVAL *	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 )

creates a linear constraint from an exact linear constraint by rounding values to floating-point and captures it

Parameters

scip	target SCIP data structure
cons	pointer to store the created target constraint
sourcescip	source SCIP data structure
name	name of constraint
nvars	number of variables in source variable array
sourcevars	source variables of the linear constraints
sourcecoefs	coefficient array of the linear constraint, or NULL if all coefficients are one
lhs	left hand side of the linear constraint
rhs	right hand side of the linear constraint
varmap	a SCIP_HASHMAP mapping variables of the source SCIP to corresponding variables of the target SCIP
consmap	a hashmap to store the mapping of source constraints to the corresponding target constraints
initial	should the LP relaxation of constraint be in the initial LP?
separate	should the constraint be separated during LP processing?
enforce	should the constraint be enforced during node processing?
check	should the constraint be checked for feasibility?
propagate	should the constraint be propagated during node processing?
local	is constraint only valid locally?
modifiable	is constraint modifiable (subject to column generation)?
dynamic	is constraint subject to aging?
removable	should the relaxation be removed from the LP due to aging or cleanup?
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node?
global	create a global or a local copy?
valid	pointer to store if the copying was valid

Definition at line 6782 of file cons_exactlinear.c.

References assert(), FALSE, i, NULL, nvars, propagate, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPallocBufferArray, SCIPcreateConsLinear(), SCIPduplicateBufferArray, SCIPfreeBufferArray, SCIPgetProbvarLinearSum(), SCIPgetVarCopy(), SCIPintervalGetSup(), SCIPisExact(), SCIPisGT(), SCIPisInfinity(), SCIPreallocBufferArray, SCIPvarGetOrigvarSum(), SCIPvarIsOriginal(), separate(), TRUE, valid, var, and vars.

Referenced by SCIP_DECL_CONSCOPY().

SCIPaddCoefExactLinear()

SCIP_RETCODE SCIPaddCoefExactLinear	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var,
		SCIP_RATIONAL *	val )

adds coefficient to linear constraint (if it is not zero)

Parameters

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

Definition at line 6919 of file cons_exactlinear.c.

References addCoef(), assert(), chgLhs(), chgRhs(), CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_STAGE_EXITPRESOLVE, SCIPABORT, SCIPallocBufferArray, SCIPblkmem(), SCIPbuffer(), SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconshdlrGetName(), SCIPerrorMessage, SCIPfreeBufferArray, SCIPgetProbvarLinearSumExact(), SCIPgetStage(), SCIPrationalCopyBlock(), SCIPrationalCreateBuffer(), SCIPrationalDiff(), SCIPrationalFreeBuffer(), SCIPrationalIsAbsInfinity(), SCIPreallocBufferArray, SCIPvarGetName(), TRUE, and var.

Referenced by readColsExact(), and SCIPchgCoefExactLinear().

SCIPchgCoefExactLinear()

SCIP_RETCODE SCIPchgCoefExactLinear	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var,
		SCIP_RATIONAL *	val )

changes coefficient of variable in linear constraint; deletes the variable if coefficient is zero; adds variable if not yet contained in the constraint

Note

This method may only be called during problem creation stage for an original constraint and variable.

This method requires linear time to search for occurences of the variable in the constraint data.

Parameters

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

Definition at line 7039 of file cons_exactlinear.c.

References assert(), chgCoefPos(), CONSHDLR_NAME, delCoefPos(), FALSE, i, NULL, nvars, SCIP_Bool, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_STAGE_PROBLEM, SCIPaddCoefExactLinear(), SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPconsIsOriginal(), SCIPerrorMessage, SCIPgetStage(), SCIPrationalIsZero(), SCIPvarIsOriginal(), TRUE, var, and vars.

Referenced by SCIPdelCoefExactLinear().

SCIPdelCoefExactLinear()

SCIP_RETCODE SCIPdelCoefExactLinear	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var )

deletes variable from linear constraint

Note

This method may only be called during problem creation stage for an original constraint and variable.

This method requires linear time to search for occurences of the variable in the constraint data.

Parameters

scip	SCIP data structure
cons	constraint data
var	variable of constraint entry

Definition at line 7107 of file cons_exactlinear.c.

References assert(), NULL, SCIP_CALL, SCIP_OKAY, SCIPbuffer(), SCIPchgCoefExactLinear(), SCIPrationalCreateBuffer(), SCIPrationalFreeBuffer(), and var.

SCIPgetLhsExactLinear()

SCIP_RATIONAL * SCIPgetLhsExactLinear	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets left hand side of linear constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 7129 of file cons_exactlinear.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by createAndAddProofcons(), readRangesExact(), readRhsExact(), SCIP_DECL_CONSCOPY(), SCIPcertificateInit(), SCIPcertificateInitTransFile(), SCIPconsGetLhsExact(), SCIPmatrixCreate(), SCIPwriteLp(), and writeOpbConstraints().

SCIPgetRhsExactLinear()

SCIP_RATIONAL * SCIPgetRhsExactLinear	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets right hand side of linear constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 7153 of file cons_exactlinear.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by createAndAddProofcons(), readRangesExact(), readRhsExact(), SCIP_DECL_CONSCOPY(), SCIPcertificateInit(), SCIPcertificateInitTransFile(), SCIPconsGetRhsExact(), SCIPmatrixCreate(), SCIPwriteLp(), writeOpbConstraints(), and writeOpbObjective().

SCIPchgLhsExactLinear()

SCIP_RETCODE SCIPchgLhsExactLinear	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_RATIONAL *	lhs )

changes left hand side of linear constraint

Parameters

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

Definition at line 7177 of file cons_exactlinear.c.

References assert(), chgLhs(), CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by readRangesExact(), and readRhsExact().

SCIPchgRhsExactLinear()

SCIP_RETCODE SCIPchgRhsExactLinear	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_RATIONAL *	rhs )

changes right hand side of linear constraint

Parameters

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

Definition at line 7198 of file cons_exactlinear.c.

References chgRhs(), CONSHDLR_NAME, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by readRangesExact(), and readRhsExact().

SCIPgetNVarsExactLinear()

int SCIPgetNVarsExactLinear	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets the number of variables in the linear constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 7216 of file cons_exactlinear.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by checkProbHasContEqs(), SCIP_DECL_CONSCOPY(), SCIPmatrixCreate(), SCIPwriteLp(), writeOpbConstraints(), and writeOpbObjective().

SCIPgetVarsExactLinear()

SCIP_VAR ** SCIPgetVarsExactLinear	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets the array of variables in the linear constraint; the user must not modify this array!

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 7240 of file cons_exactlinear.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by checkProbHasContEqs(), SCIP_DECL_CONSCOPY(), SCIPmatrixCreate(), SCIPwriteLp(), writeOpbConstraints(), and writeOpbObjective().

SCIPgetValsRealExactLinear()

SCIP_INTERVAL * SCIPgetValsRealExactLinear	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets the array of coefficient values in the linear constraint; the user must not modify this array!

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 7264 of file cons_exactlinear.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by SCIP_DECL_CONSCOPY().

SCIPgetValsExactLinear()

SCIP_RATIONAL ** SCIPgetValsExactLinear	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets the array of coefficient values in the linear constraint; the user must not modify this array!

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 7288 of file cons_exactlinear.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by SCIPgetConsValsExact(), SCIPmatrixCreate(), SCIPwriteLp(), and writeOpbConstraints().

SCIPgetActivityExactLinear()

SCIP_RETCODE SCIPgetActivityExactLinear	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SOL *	sol,
		SCIP_RATIONAL *	ret )

gets the activity of the linear constraint in the given solution

Note

if the activity comprises positive and negative infinity contributions, the result is currently undefined

Parameters

scip	SCIP data structure
cons	constraint data
sol	solution, or NULL to use current node's solution
ret	pointer to store result

Definition at line 7315 of file cons_exactlinear.c.

References assert(), consdataGetActivity(), CONSHDLR_NAME, FALSE, NULL, SCIP_CALL, SCIP_OKAY, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPerrorMessage, SCIPgetRowSolActivityExact(), SCIPrationalSetInfinity(), sol, and TRUE.

SCIPgetFeasibilityExactLinear()

SCIP_RETCODE SCIPgetFeasibilityExactLinear	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SOL *	sol,
		SCIP_RATIONAL *	ret )

gets the feasibility of the linear constraint in the given solution

Parameters

scip	SCIP data structure
cons	constraint data
sol	solution, or NULL to use current node's solution
ret	pointer to store the result

Definition at line 7348 of file cons_exactlinear.c.

References assert(), consdataGetFeasibility(), CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_OKAY, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPerrorMessage, SCIPgetRowSolFeasibilityExact(), and sol.

SCIPgetFpDualsolExactLinear()

void SCIPgetFpDualsolExactLinear	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_RATIONAL *	ret )

gets the dual solution of the linear constraint in the current LP

Note

this method currently returns the value from the floating-point LP

Parameters

scip	SCIP data structure
cons	constraint data
ret	result pointer

Definition at line 7381 of file cons_exactlinear.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPconsIsOriginal(), SCIPerrorMessage, SCIPrationalSetReal(), and SCIProwGetDualsol().

SCIPgetFpDualfarkasExactLinear()

void SCIPgetFpDualfarkasExactLinear	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_RATIONAL *	ret )

gets the dual Farkas value of the linear constraint in the current infeasible LP

Note

this method currently returns the value from the floating-point LP

gets the dual Farkas value of the linear constraint in the current infeasible LP

Note

this method currently returns an approximate value from the floating-point LP

Parameters

scip	SCIP data structure
cons	constraint data
ret	result pointer

Definition at line 7412 of file cons_exactlinear.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPconsIsOriginal(), SCIPerrorMessage, SCIPrationalSetReal(), and SCIProwGetDualfarkas().

SCIPgetRowExactLinear()

SCIP_ROW * SCIPgetRowExactLinear	(	SCIP *	scip,
		SCIP_CONS *	cons )

returns the linear relaxation of the given linear constraint; may return NULL if no LP row was yet created; the user must not modify the row!

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 7442 of file cons_exactlinear.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by SCIPconsGetRow().

SCIPgetRowExactExactLinear()

SCIP_ROWEXACT * SCIPgetRowExactExactLinear	(	SCIP *	scip,
		SCIP_CONS *	cons )

returns the exact linear relaxation of the given linear constraint; may return NULL if no LP row was yet created; the user must not modify the row!

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 7468 of file cons_exactlinear.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by SCIPconsPrintCertificateExactLinear().

SCIPcertifyConsOrigExactLinear()

SCIP_RETCODE SCIPcertifyConsOrigExactLinear	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_CONS *	cons )

prints the certificate for a given original exact linear constraint

Parameters

scip	SCIP data structure
conshdlr	constraint handler
cons	constraint

Definition at line 2981 of file cons_exactlinear.c.

References assert(), i, NULL, SCIP_CALL, SCIP_OKAY, SCIPallocBufferArray, SCIPcertifyCons(), SCIPconsGetData(), SCIPfreeBufferArray, SCIPisCertified(), SCIPrationalIsAbsInfinity(), SCIPrationalIsEQ(), SCIPrationalIsInfinity(), SCIPrationalIsNegInfinity(), SCIPvarGetCertificateIndex(), and TRUE.

Referenced by SCIPcertificateInit().

SCIPcreateConsIndicator()

SCIP_RETCODE SCIPcreateConsIndicator	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_VAR *	binvar,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_Real *	vals,
		SCIP_Real	rhs,
		SCIP_Bool	initial,
		SCIP_Bool	separate,
		SCIP_Bool	enforce,
		SCIP_Bool	check,
		SCIP_Bool	propagate,
		SCIP_Bool	local,
		SCIP_Bool	dynamic,
		SCIP_Bool	removable,
		SCIP_Bool	stickingatnode )

creates and captures an indicator constraint

Note

binvar is checked to be binary only later. This enables a change of the type in procedures reading an instance.

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint (indicator or quadratic)
name	name of constraint
binvar	binary indicator variable (or NULL)
nvars	number of variables in the inequality
vars	array with variables of inequality (or NULL)
vals	values of variables in inequality (or NULL)
rhs	rhs of the inequality
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 7891 of file cons_indicator.c.

References nvars, propagate, SCIP_Bool, SCIP_Real, SCIPcreateConsIndicatorGeneric(), separate(), TRUE, and vars.

Referenced by createIndicatorConstraint(), readIndicators(), SCIP_DECL_CONSINITPRE(), SCIP_DECL_LINCONSUPGD(), SCIPcreateConsBasicIndicator(), and upgradeIndicatorSuperindicator().

SCIPcreateConsBasicIndicator()

SCIP_RETCODE SCIPcreateConsBasicIndicator	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_VAR *	binvar,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_Real *	vals,
		SCIP_Real	rhs )

creates and captures an indicator constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsIndicator(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h

See also

SCIPcreateConsIndicator() for information about the basic constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint (indicator or quadratic)
name	name of constraint
binvar	binary indicator variable (or NULL)
nvars	number of variables in the inequality
vars	array with variables of inequality (or NULL)
vals	values of variables in inequality (or NULL)
rhs	rhs of the inequality

Definition at line 8217 of file cons_indicator.c.

References assert(), FALSE, NULL, nvars, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPcreateConsIndicator(), TRUE, and vars.

SCIPcreateConsIndicatorGeneric()

SCIP_RETCODE SCIPcreateConsIndicatorGeneric	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_VAR *	binvar,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_Real *	vals,
		SCIP_Real	rhs,
		SCIP_Bool	activeone,
		SCIP_Bool	lessthanineq,
		SCIP_Bool	initial,
		SCIP_Bool	separate,
		SCIP_Bool	enforce,
		SCIP_Bool	check,
		SCIP_Bool	propagate,
		SCIP_Bool	local,
		SCIP_Bool	dynamic,
		SCIP_Bool	removable,
		SCIP_Bool	stickingatnode )

creates and captures a indicator constraint in a more generic version.

The key difference from SCIPcreateConsIndicator() is the activeone and lessthanineq Booleans. If \(z = o\), with \(o\) the activeone flag, then: if lessthanineq then \(a^T x \leq b\) holds, else the passed vectors are assumed to be of the form \(a^T x \geq b\). The underlying linear constraint is always created as a less-than inequality.

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint (indicator or quadratic)
name	name of constraint
binvar	binary indicator variable (or NULL)
nvars	number of variables in the inequality
vars	array with variables of inequality (or NULL)
vals	values of variables in inequality (or NULL)
rhs	rhs of the inequality
activeone	is the constraint active when the binary is 1?
lessthanineq	is the linear constraint a less than RHS (TRUE) or greater than RHS (FALSE)?
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 7932 of file cons_indicator.c.

References assert(), consdataCreate(), CONSHDLR_NAME, FALSE, NULL, nvars, propagate, REALABS, SCIP_Bool, SCIP_CALL, SCIP_EVENTTYPE_BOUNDCHANGED, SCIP_IMPLINTTYPE_NONE, SCIP_IMPLINTTYPE_WEAK, SCIP_INVALIDDATA, SCIP_MAXSTRLEN, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIP_Real, SCIP_VARTYPE_CONTINUOUS, SCIPaddCoefLinear(), SCIPaddCons(), SCIPaddVar(), SCIPallocBufferArray, SCIPblkmem(), SCIPcaptureVar(), SCIPcatchVarEvent(), SCIPceil(), SCIPchgVarImplType(), SCIPchgVarType(), SCIPconsAddUpgradeLocks(), SCIPconsGetNUpgradeLocks(), SCIPconshdlrGetData(), SCIPcreateCons(), SCIPcreateConsLinear(), SCIPcreateConsQuadraticNonlinear(), SCIPcreateVarImpl(), SCIPerrorMessage, SCIPfindConshdlr(), SCIPfreeBufferArray, SCIPgetNegatedVar(), SCIPgetNOrigVars(), SCIPhashmapCreate(), SCIPhashmapExists(), SCIPhashmapGetImage(), SCIPhashmapInsert(), SCIPinfinity(), SCIPisIntegral(), SCIPisTransformed(), SCIPisZero(), SCIPmarkDoNotMultaggrVar(), SCIPsnprintf(), SCIPvarIsBinary(), SCIPvarIsIntegral(), separate(), TRUE, and vars.

Referenced by SCIPcreateConsIndicator().

SCIPcreateConsIndicatorLinCons()

SCIP_RETCODE SCIPcreateConsIndicatorLinCons	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_VAR *	binvar,
		SCIP_CONS *	lincons,
		SCIP_VAR *	slackvar,
		SCIP_Bool	initial,
		SCIP_Bool	separate,
		SCIP_Bool	enforce,
		SCIP_Bool	check,
		SCIP_Bool	propagate,
		SCIP_Bool	local,
		SCIP_Bool	dynamic,
		SCIP_Bool	removable,
		SCIP_Bool	stickingatnode )

creates and captures an indicator constraint with given linear constraint and slack variable

Note

binvar is checked to be binary only later. This enables a change of the type in procedures reading an instance.

we assume that slackvar actually appears in lincons and we also assume that it takes the role of a slack variable!

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
binvar	binary indicator variable
lincons	linear constraint
slackvar	slack variable
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 8398 of file cons_indicator.c.

References propagate, SCIP_Bool, SCIPcreateConsIndicatorGenericLinCons(), separate(), and TRUE.

Referenced by createSubSCIP(), SCIP_DECL_CONSPARSE(), and SCIPcreateConsBasicIndicatorLinCons().

SCIPcreateConsIndicatorGenericLinCons()

SCIP_RETCODE SCIPcreateConsIndicatorGenericLinCons	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_VAR *	binvar,
		SCIP_CONS *	lincons,
		SCIP_VAR *	slackvar,
		SCIP_Bool	activeone,
		SCIP_Bool	initial,
		SCIP_Bool	separate,
		SCIP_Bool	enforce,
		SCIP_Bool	check,
		SCIP_Bool	propagate,
		SCIP_Bool	local,
		SCIP_Bool	dynamic,
		SCIP_Bool	removable,
		SCIP_Bool	stickingatnode )

creates and captures an indicator constraint with given linear constraint and slack variable in a generic version, i. e., with a flag activeone indicating whether the constraint is active on value 1 or 0 of the binary variable.

Note

binvar is checked to be binary only later. This enables a change of the type in procedures reading an instance.

we assume that slackvar actually appears in lincons and we also assume that it takes the role of a slack variable!

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

See also

SCIPcreateConsIndicatorLinCons() for information about the basic constraint flag configuration

creates and captures an indicator constraint with given linear constraint and slack variable in a generic version, i.e., with a flag activeone indicating whether the constraint is active on value 1 or 0 of the binary variable.

Note

binvar is checked to be binary only later. This enables a change of the type in procedures reading an instance.

we assume that slackvar actually appears in lincons and we also assume that it takes the role of a slack variable!

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

See also

SCIPcreateConsIndicatorLinCons() for information about the basic constraint flag configuration

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
binvar	binary indicator variable
lincons	linear constraint
slackvar	slack variable
activeone	is the constraint active when the binary is 1?
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 8250 of file cons_indicator.c.

References assert(), consdataCreate(), CONSHDLR_NAME, FALSE, NULL, nvars, propagate, SCIP_Bool, SCIP_CALL, SCIP_EVENTTYPE_BOUNDCHANGED, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIP_Real, SCIPcaptureCons(), SCIPcaptureVar(), SCIPcatchVarEvent(), SCIPconsAddUpgradeLocks(), SCIPconsGetHdlr(), SCIPconsGetNUpgradeLocks(), SCIPconshdlrGetData(), SCIPconshdlrGetName(), SCIPcreateCons(), SCIPcreateConsQuadraticNonlinear(), SCIPerrorMessage, SCIPfindConshdlr(), SCIPgetNegatedVar(), SCIPgetNVarsLinear(), SCIPgetVarsLinear(), SCIPisTransformed(), SCIPmarkDoNotMultaggrVar(), SCIPvarIsBinary(), SCIPvarIsIntegral(), separate(), TRUE, and vars.

Referenced by SCIP_DECL_CONSCOPY(), and SCIPcreateConsIndicatorLinCons().

SCIPcreateConsBasicIndicatorLinCons()

SCIP_RETCODE SCIPcreateConsBasicIndicatorLinCons	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_VAR *	binvar,
		SCIP_CONS *	lincons,
		SCIP_VAR *	slackvar )

creates and captures an indicator constraint with given linear constraint and slack variable in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsIndicator(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h

Note

binvar is checked to be binary only later. This enables a change of the type in procedures reading an instance.

we assume that slackvar actually appears in lincons and we also assume that it takes the role of a slack variable!

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

See also

SCIPcreateConsIndicatorLinCons() for information about the basic constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
binvar	binary indicator variable
lincons	linear constraint
slackvar	slack variable

Definition at line 8447 of file cons_indicator.c.

References assert(), FALSE, NULL, SCIP_CALL, SCIP_OKAY, SCIPcreateConsIndicatorLinCons(), and TRUE.

SCIPcreateConsIndicatorGenericLinConsPure()

SCIP_RETCODE SCIPcreateConsIndicatorGenericLinConsPure	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_VAR *	binvar,
		SCIP_CONS *	lincons,
		SCIP_Bool	activeone,
		SCIP_Bool	initial,
		SCIP_Bool	separate,
		SCIP_Bool	enforce,
		SCIP_Bool	check,
		SCIP_Bool	propagate,
		SCIP_Bool	local,
		SCIP_Bool	dynamic,
		SCIP_Bool	removable,
		SCIP_Bool	stickingatnode )

creates and captures an indicator constraint with given linear constraint in a generic version, i. e., with a flag activeone indicating whether the constraint is active on value 1 or 0 of the binary variable; no slack variable is specified

Note

binvar is checked to be binary only later. This enables a change of the type in procedures reading an instance.

The linear constraint has to be single sided only, i.e., either rhs or lhs have to be infinite.

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

See also

SCIPcreateConsIndicatorLinCons() for information about the basic constraint flag configuration

creates and captures an indicator constraint with given linear constraint in a generic version, i. e., with a flag activeone indicating whether the constraint is active on value 1 or 0 of the binary variable; no slack variable is given

Note

binvar is checked to be binary only later. This enables a change of the type in procedures reading an instance.

The linear constraint must be single-sided, i.e., either rhs or lhs have to be infinite.

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

See also

SCIPcreateConsIndicatorLinCons() for information about the basic constraint flag configuration

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
binvar	binary indicator variable
lincons	linear constraint
activeone	is the constraint active when the binary is 1?
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 8478 of file cons_indicator.c.

References assert(), consdataCreate(), CONSHDLR_NAME, FALSE, NULL, nvars, propagate, SCIP_Bool, SCIP_CALL, SCIP_EVENTTYPE_BOUNDCHANGED, SCIP_IMPLINTTYPE_NONE, SCIP_IMPLINTTYPE_WEAK, SCIP_INVALIDDATA, SCIP_MAXSTRLEN, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIP_Real, SCIP_VARTYPE_CONTINUOUS, SCIPaddCoefLinear(), SCIPaddVar(), SCIPblkmem(), SCIPcaptureCons(), SCIPcaptureVar(), SCIPcatchVarEvent(), SCIPchgVarImplType(), SCIPchgVarType(), SCIPconsAddUpgradeLocks(), SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconsGetNUpgradeLocks(), SCIPconshdlrGetData(), SCIPconshdlrGetName(), SCIPcreateCons(), SCIPcreateConsQuadraticNonlinear(), SCIPcreateVarImpl(), SCIPdoNotMultaggrVar(), SCIPerrorMessage, SCIPfindConshdlr(), SCIPgetLhsLinear(), SCIPgetNegatedVar(), SCIPgetNOrigVars(), SCIPgetNVarsLinear(), SCIPgetRhsLinear(), SCIPgetValsLinear(), SCIPgetVarsLinear(), SCIPhashmapCreate(), SCIPhashmapExists(), SCIPhashmapGetImage(), SCIPhashmapInsert(), SCIPinfinity(), SCIPisInfinity(), SCIPisIntegral(), SCIPisTransformed(), SCIPmarkDoNotMultaggrVar(), SCIPsnprintf(), SCIPvarGetName(), SCIPvarIsBinary(), SCIPvarIsIntegral(), separate(), TRUE, and vars.

Referenced by SCIPcreateConsIndicatorLinConsPure().

SCIPcreateConsIndicatorLinConsPure()

SCIP_RETCODE SCIPcreateConsIndicatorLinConsPure	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_VAR *	binvar,
		SCIP_CONS *	lincons,
		SCIP_Bool	initial,
		SCIP_Bool	separate,
		SCIP_Bool	enforce,
		SCIP_Bool	check,
		SCIP_Bool	propagate,
		SCIP_Bool	local,
		SCIP_Bool	dynamic,
		SCIP_Bool	removable,
		SCIP_Bool	stickingatnode )

creates and captures an indicator constraint with given linear constraint; no slack variable is specified

Note

binvar is checked to be binary only later. This enables a change of the type in procedures reading an instance.

The linear constraint has to be single sided only, i.e., either rhs or lhs have to be infinite.

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
binvar	binary indicator variable
lincons	linear constraint
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 8701 of file cons_indicator.c.

References propagate, SCIP_Bool, SCIPcreateConsIndicatorGenericLinConsPure(), separate(), and TRUE.

Referenced by readIndicators().

SCIPaddVarIndicator()

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

adds variable to the inequality of the indicator constraint

Parameters

scip	SCIP data structure
cons	indicator constraint
var	variable to add to the inequality
val	value of variable

Definition at line 8734 of file cons_indicator.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_Bool, SCIP_CALL, SCIP_IMPLINTTYPE_NONE, SCIP_OKAY, SCIP_Real, SCIP_VARTYPE_CONTINUOUS, SCIPaddCoefLinear(), SCIPchgVarImplType(), SCIPchgVarType(), SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPisIntegral(), SCIPvarIsIntegral(), and var.

SCIPgetLinearConsIndicator()

SCIP_CONS * SCIPgetLinearConsIndicator

(

SCIP_CONS *

cons

)

gets the linear constraint corresponding to the indicator constraint (may be NULL)

Parameters

cons	indicator constraint

Definition at line 8771 of file cons_indicator.c.

References assert(), CONSHDLR_NAME, NULL, SCIPconsGetData(), SCIPconsGetHdlr(), and SCIPconshdlrGetName().

Referenced by computeRanks(), createSubSCIP(), getNVarsIndicators(), hasUnfixedSCIndicator(), SCIP_DECL_DIVESETGETSCORE(), SCIP_DECL_LINCONSUPGD(), SCIPwriteLp(), SCIPwriteMps(), and writeOpbConstraints().

SCIPsetLinearConsIndicator()

SCIP_RETCODE SCIPsetLinearConsIndicator	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_CONS *	lincons )

sets the linear constraint corresponding to the indicator constraint (may be NULL)

Parameters

scip	SCIP data structure
cons	indicator constraint
lincons	linear constraint

Definition at line 8788 of file cons_indicator.c.

References assert(), CONSHDLR_NAME, NULL, nvars, SCIP_CALL, SCIP_INVALIDCALL, SCIP_OKAY, SCIP_STAGE_PROBLEM, SCIPcaptureCons(), SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetData(), SCIPconshdlrGetName(), SCIPdelCons(), SCIPerrorMessage, SCIPgetNVarsLinear(), SCIPgetStage(), SCIPgetVarsLinear(), SCIPreleaseCons(), SCIPvarIsIntegral(), TRUE, and vars.

SCIPsetBinaryVarIndicator()

SCIP_RETCODE SCIPsetBinaryVarIndicator	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	binvar )

sets binary indicator variable for indicator constraint

Parameters

scip	SCIP data structure
cons	indicator constraint
binvar	binary variable to add to the inequality

Definition at line 8900 of file cons_indicator.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_ERROR, SCIP_EVENTTYPE_BOUNDCHANGED, SCIP_EVENTTYPE_GBDCHANGED, SCIP_INVALIDCALL, SCIP_OKAY, SCIPcatchVarEvent(), SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconshdlrGetData(), SCIPconshdlrGetName(), SCIPconsIsTransformed(), SCIPerrorMessage, SCIPgetNegatedVar(), SCIPgetTransformedVar(), SCIPvarGetLbLocal(), SCIPvarGetName(), SCIPvarGetType(), SCIPvarIsBinary(), SCIPvarIsImpliedIntegral(), and var.

SCIPgetActiveOnIndicator()

SCIP_Bool SCIPgetActiveOnIndicator

(

SCIP_CONS *

cons

)

gets activation value of an indicator constraint, TRUE for active on 1, FALSE for active on 0

Parameters

cons	indicator constraint

Definition at line 8845 of file cons_indicator.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_Bool, SCIPconsGetData(), SCIPconsGetHdlr(), and SCIPconshdlrGetName().

SCIPgetBinaryVarIndicator()

SCIP_VAR * SCIPgetBinaryVarIndicator

(

SCIP_CONS *

cons

)

gets binary variable corresponding to indicator constraint. Returns the negative of the original binary variable if activeone was set to false

gets binary variable corresponding to indicator constraint

Parameters

cons	indicator constraint

Definition at line 8862 of file cons_indicator.c.

References assert(), CONSHDLR_NAME, NULL, SCIPconsGetData(), SCIPconsGetHdlr(), and SCIPconshdlrGetName().

Referenced by computeRanks(), createCoveringProblem(), createMaps(), createSubSCIP(), hasUnfixedSCIndicator(), isViolatedAndNotFixed(), SCIP_DECL_CONFLICTEXEC(), SCIP_DECL_CONSGETDIVEBDCHGS(), SCIP_DECL_HEUREXEC(), SCIPwriteGms(), SCIPwriteLp(), SCIPwriteMps(), tryOneOpt(), trySolCandidate(), and writeOpbConstraints().

SCIPgetBinaryVarIndicatorGeneric()

SCIP_VAR * SCIPgetBinaryVarIndicatorGeneric

(

SCIP_CONS *

cons

)

similar to SCIPgetBinaryVarIndicator but returns the original binary variable passed by the user.

Parameters

cons	indicator constraint

Definition at line 8878 of file cons_indicator.c.

References assert(), CONSHDLR_NAME, NULL, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPvarGetNegationVar().

SCIPgetSlackVarIndicator()

SCIP_VAR * SCIPgetSlackVarIndicator

(

SCIP_CONS *

cons

)

gets slack variable corresponding to indicator constraint

Parameters

cons	indicator constraint

Definition at line 8981 of file cons_indicator.c.

References assert(), CONSHDLR_NAME, NULL, SCIPconsGetData(), SCIPconsGetHdlr(), and SCIPconshdlrGetName().

Referenced by createSubSCIP(), getNVarsIndicators(), hasUnfixedSCIndicator(), SCIP_DECL_CONFLICTEXEC(), SCIP_DECL_DIVESETGETSCORE(), SCIPwriteGms(), SCIPwriteLp(), SCIPwriteMps(), and writeOpbConstraints().

SCIPsetSlackVarUb()

SCIP_RETCODE SCIPsetSlackVarUb	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Real	ub )

sets upper bound for slack variable corresponding to indicator constraint

Use with care if you know that the maximal violation of the corresponding constraint is at most ub. This bound might be improved automatically during the solution process.

Precondition

This method should only be called if SCIP is in one of the following stages:

• SCIP_STAGE_INIT
• SCIP_STAGE_PROBLEM

Parameters

scip	SCIP data structure
cons	indicator constraint
ub	upper bound for slack variable

Definition at line 9006 of file cons_indicator.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIP_STAGE_PROBLEM, SCIPchgVarUb(), SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPgetStage().

SCIPisViolatedIndicator()

SCIP_Bool SCIPisViolatedIndicator	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SOL *	sol )

checks whether indicator constraint is violated w.r.t. sol

Parameters

scip	SCIP data structure
cons	indicator constraint
sol	solution, or NULL to use current node's solution

Definition at line 9032 of file cons_indicator.c.

References assert(), FALSE, NULL, SCIP_Bool, SCIPconsGetData(), SCIPconsIsDeleted(), SCIPgetSolVal(), SCIPisFeasPositive(), sol, and TRUE.

Referenced by isViolatedAndNotFixed(), and SCIP_DECL_CONSGETDIVEBDCHGS().

SCIPmakeIndicatorFeasible()

SCIP_RETCODE SCIPmakeIndicatorFeasible	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SOL *	sol,
		SCIP_Bool *	changed )

based on values of other variables, computes slack and binary variable to turn constraint feasible

based on values of other variables, computes slack and binary variable to turn constraint feasible

It will also clean up the solution, i.e., shift slack variable, as follows:

If the inequality is \(a^T x + \gamma\, s \leq \beta\), the value of the slack variable \(s\) to achieve equality is

\[ s^* = \frac{\beta - a^T x^*}{\gamma}, \]

where \(x^*\) is the given solution. In case of \(a^T x + \gamma\, s \geq \alpha\), we arrive at

\[ s^* = \frac{\alpha - a^T x^*}{\gamma}. \]

The typical values of \(\gamma\) in the first case is -1 and +1 in the second case.

Now, let \(\sigma\) be the sign of \(\gamma\) in the first case and \(-\gamma\) in the second case. Thus, if \(\sigma > 0\) and \(s^* < 0\), the inequality cannot be satisfied by a nonnegative value for the slack variable; in this case, we have to leave the values as they are. If \(\sigma < 0\) and \(s^* > 0\), the solution violates the indicator constraint (we can set the slack variable to value \(s^*\)). If \(\sigma < 0\) and \(s^* \leq 0\) or \(\sigma > 0\) and \(s^* \geq 0\), the constraint is satisfied, and we can set the slack variable to 0.

Parameters

scip	SCIP data structure
cons	indicator constraint
sol	solution
changed	pointer to store whether the solution has been changed

Definition at line 9087 of file cons_indicator.c.

References assert(), CONSHDLR_NAME, FALSE, NULL, obj, REALABS, SCIP_Bool, SCIP_CALL, SCIP_LOCKTYPE_MODEL, SCIP_OKAY, SCIP_Real, SCIP_STAGE_INITPRESOLVE, SCIP_VARSTATUS_FIXED, SCIP_VARSTATUS_NEGATED, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPconsIsActive(), SCIPgetLhsLinear(), SCIPgetNVarsLinear(), SCIPgetRhsLinear(), SCIPgetSolVal(), SCIPgetStage(), SCIPgetValsLinear(), SCIPgetVarsLinear(), SCIPisFeasEQ(), SCIPisFeasGE(), SCIPisFeasNegative(), SCIPisFeasPositive(), SCIPisFeasZero(), SCIPisInfinity(), SCIPisZero(), SCIPsetSolVal(), SCIPvarGetLbLocal(), SCIPvarGetNegationVar(), SCIPvarGetNLocksDownType(), SCIPvarGetNLocksUpType(), SCIPvarGetStatus(), sol, TRUE, var, and varGetObjDelta().

Referenced by SCIP_DECL_CONSCHECK(), and SCIPmakeIndicatorsFeasible().

SCIPmakeIndicatorsFeasible()

SCIP_RETCODE SCIPmakeIndicatorsFeasible	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_SOL *	sol,
		SCIP_Bool *	changed )

based on values of other variables, computes slack and binary variable to turn all constraints feasible

Parameters

scip	SCIP data structure
conshdlr	indicator constraint handler
sol	solution
changed	pointer to store whether the solution has been changed

Definition at line 9262 of file cons_indicator.c.

References assert(), c, CONSHDLR_NAME, FALSE, NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_STAGE_INITPRESOLVE, SCIPconsGetData(), SCIPconshdlrGetConss(), SCIPconshdlrGetName(), SCIPconshdlrGetNConss(), SCIPgetStage(), SCIPmakeIndicatorFeasible(), and sol.

Referenced by SCIPperformGenericDivingAlgorithm().

SCIPaddLinearConsIndicator()

SCIP_RETCODE SCIPaddLinearConsIndicator	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_CONS *	lincons )

adds additional linear constraint that is not connected with an indicator constraint, but can be used for separation

Parameters

scip	SCIP data structure
conshdlr	indicator constraint handler
lincons	linear constraint

Definition at line 9309 of file cons_indicator.c.

References assert(), consdataEnsureAddLinConsSize(), CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_OKAY, SCIPconshdlrGetData(), SCIPconshdlrGetName(), SCIPconsIsLocal(), and SCIPconsIsModifiable().

SCIPaddRowIndicator()

SCIP_RETCODE SCIPaddRowIndicator	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_ROW *	row )

adds additional globally valid row that is not connected with an indicator constraint, but can be used for separation

adds additional row that is not connected with an indicator constraint, but can be used for separation

Note

The row is directly added to the alternative polyhedron and is not stored.

Parameters

scip	SCIP data structure
conshdlr	indicator constraint handler
row	row to add

Definition at line 9341 of file cons_indicator.c.

References addAltLPRow(), assert(), CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_OKAY, SCIPconshdlrGetData(), SCIPconshdlrGetName(), SCIPdebugMsg, SCIProwGetName(), and SCIProwIsLocal().

SCIPcreateConsKnapsack()

SCIP_RETCODE SCIPcreateConsKnapsack	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_Longint *	weights,
		SCIP_Longint	capacity,
		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 )

creates and captures a knapsack constraint

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

creates and captures a knapsack constraint

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons() ! [SnippetConsCreationKnapsack]

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nvars	number of items in the knapsack
vars	array with item variables
weights	array with item weights
capacity	capacity of knapsack (right hand side of inequality)
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 13660 of file cons_knapsack.c.

References assert(), catchEvents(), consdataCreate(), CONSHDLR_NAME, i, NULL, nvars, propagate, SCIP_Bool, SCIP_CALL, SCIP_INVALIDDATA, SCIP_Longint, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIPconshdlrGetData(), SCIPcreateCons(), SCIPerrorMessage, SCIPfindConshdlr(), SCIPisTransformed(), SCIPvarGetName(), SCIPvarIsBinary(), separate(), and vars.

Referenced by createAndAddLinearCons(), createCapacityRestriction(), createMipCpFormulation(), createNormalizedKnapsack(), createRow(), presolRoundCardinality(), SCIP_DECL_CONSPARSE(), SCIP_DECL_PRESOLEXEC(), and SCIPcreateConsBasicKnapsack().

SCIPcreateConsBasicKnapsack()

SCIP_RETCODE SCIPcreateConsBasicKnapsack	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_Longint *	weights,
		SCIP_Longint	capacity )

creates and captures a knapsack constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsKnapsack(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h

See also

SCIPcreateConsKnapsack() for information about the basic constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

! [SnippetConsCreationKnapsack] creates and captures a knapsack constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsKnapsack(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h

See also

SCIPcreateConsKnapsack() for information about the basic constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nvars	number of items in the knapsack
vars	array with item variables
weights	array with item weights
capacity	capacity of knapsack

Definition at line 13747 of file cons_knapsack.c.

References assert(), FALSE, NULL, nvars, SCIP_CALL, SCIP_Longint, SCIP_OKAY, SCIPcreateConsKnapsack(), TRUE, and vars.

Referenced by createIntervalRelaxation(), createMipFormulation(), and initPricing().

SCIPaddCoefKnapsack()

SCIP_RETCODE SCIPaddCoefKnapsack	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var,
		SCIP_Longint	weight )

adds new item to knapsack constraint

Parameters

scip	SCIP data structure
cons	constraint data
var	item variable
weight	item weight

Definition at line 13766 of file cons_knapsack.c.

References addCoef(), assert(), CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_INVALIDDATA, SCIP_Longint, SCIP_OKAY, SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPerrorMessage, and var.

Referenced by addCoefTerm(), createCapacityRestriction(), createIntervalRelaxation(), createMipCpFormulation(), createMipFormulation(), SCIPaddCoefPseudoboolean(), and SCIPconsAddCoef().

SCIPgetCapacityKnapsack()

SCIP_Longint SCIPgetCapacityKnapsack	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets the capacity of the knapsack constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 13788 of file cons_knapsack.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_Longint, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by addKnapsackConstraints(), addSymmetryInformation(), checkKnapsack(), createAltLP(), createAltLP(), getLinearConsSides(), matrixCreate(), presolveAddKKTKnapsackConss(), SCIP_DECL_CONSCOPY(), SCIP_DECL_PRESOLEXEC(), SCIPconsGetRhs(), SCIPmatrixCreate(), SCIPwriteGms(), SCIPwriteLp(), SCIPwriteMps(), SCIPwritePip(), writeFzn(), writeOpbConstraints(), and writeOpbObjective().

SCIPchgCapacityKnapsack()

SCIP_RETCODE SCIPchgCapacityKnapsack	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Longint	capacity )

changes capacity of the knapsack constraint

Note

This method can only be called during problem creation stage (SCIP_STAGE_PROBLEM)

Parameters

scip	SCIP data structure
cons	constraint data
capacity	new capacity of knapsack

Definition at line 13814 of file cons_knapsack.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_INVALIDDATA, SCIP_Longint, SCIP_OKAY, SCIP_STAGE_PROBLEM, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPerrorMessage, and SCIPgetStage().

SCIPgetNVarsKnapsack()

int SCIPgetNVarsKnapsack	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets the number of items in the knapsack constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 13845 of file cons_knapsack.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by addKnapsackConstraints(), addSymmetryInformation(), checkKnapsack(), createAltLP(), createAltLP(), SCIPNLFeeder::FeedLinearConExpr(), getLinearConsNVars(), getLinearConsVarsData(), matrixCreate(), presolveAddKKTKnapsackConss(), SCIP_DECL_CONSCOPY(), SCIP_DECL_PRESOLEXEC(), SCIPmatrixCreate(), SCIPwriteCcg(), SCIPwriteGms(), SCIPwriteLp(), SCIPwriteMps(), SCIPwritePbm(), SCIPwritePip(), SCIPwritePpm(), writeFzn(), writeOpbConstraints(), and writeOpbObjective().

SCIPgetVarsKnapsack()

SCIP_VAR ** SCIPgetVarsKnapsack	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets the array of variables in the knapsack constraint; the user must not modify this array!

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 13868 of file cons_knapsack.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by addKnapsackConstraints(), addSymmetryInformation(), checkKnapsack(), createAltLP(), createAltLP(), SCIPNLFeeder::FeedLinearConExpr(), getLinearConsVarsData(), matrixCreate(), presolveAddKKTKnapsackConss(), SCIP_DECL_CONSCOPY(), SCIPmatrixCreate(), SCIPwriteCcg(), SCIPwriteGms(), SCIPwriteLp(), SCIPwriteMps(), SCIPwritePbm(), SCIPwritePip(), SCIPwritePpm(), writeFzn(), writeOpbConstraints(), and writeOpbObjective().

SCIPgetWeightsKnapsack()

SCIP_Longint * SCIPgetWeightsKnapsack	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets the array of weights in the knapsack constraint; the user must not modify this array!

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 13891 of file cons_knapsack.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_Longint, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by addKnapsackConstraints(), addSymmetryInformation(), checkKnapsack(), createAltLP(), createAltLP(), SCIPNLFeeder::FeedLinearConExpr(), getLinearConsVarsData(), matrixCreate(), presolveAddKKTKnapsackConss(), SCIP_DECL_CONSCOPY(), SCIP_DECL_PRESOLEXEC(), SCIPgetConsVals(), SCIPmatrixCreate(), SCIPwriteCcg(), SCIPwriteGms(), SCIPwriteLp(), SCIPwriteMps(), SCIPwritePbm(), SCIPwritePip(), SCIPwritePpm(), writeFzn(), and writeOpbConstraints().

SCIPgetDualsolKnapsack()

SCIP_Real SCIPgetDualsolKnapsack	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets the dual solution of the knapsack constraint in the current LP

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 13914 of file cons_knapsack.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_INVALID, SCIP_Real, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPerrorMessage, and SCIProwGetDualsol().

Referenced by SCIPconsGetDualsol().

SCIPgetDualfarkasKnapsack()

SCIP_Real SCIPgetDualfarkasKnapsack	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets the dual Farkas value of the knapsack constraint in the current infeasible LP

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 13940 of file cons_knapsack.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_INVALID, SCIP_Real, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPerrorMessage, and SCIProwGetDualfarkas().

Referenced by SCIPconsGetDualfarkas().

SCIPgetRowKnapsack()

SCIP_ROW * SCIPgetRowKnapsack	(	SCIP *	scip,
		SCIP_CONS *	cons )

returns the linear relaxation of the given knapsack constraint; may return NULL if no LP row was yet created; the user must not modify the row!

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 13968 of file cons_knapsack.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by SCIPconsCreateRow(), and SCIPconsGetRow().

SCIPcreateRowKnapsack()

SCIP_RETCODE SCIPcreateRowKnapsack	(	SCIP *	scip,
		SCIP_CONS *	cons )

creates and returns the row of the given knapsack constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 13991 of file cons_knapsack.c.

References assert(), CONSHDLR_NAME, i, NULL, SCIP_CALL, SCIP_ERROR, SCIP_OKAY, SCIP_Real, SCIPABORT, SCIPaddVarToRow(), SCIPcacheRowExtensions(), SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconshdlrGetName(), SCIPconsIsLocal(), SCIPconsIsModifiable(), SCIPconsIsRemovable(), SCIPcreateEmptyRowCons(), SCIPerrorMessage, SCIPflushRowExtensions(), and SCIPinfinity().

Referenced by SCIPconsCreateRow().

SCIPsolveKnapsackExactly()

SCIP_RETCODE SCIPsolveKnapsackExactly	(	SCIP *	scip,
		int	nitems,
		SCIP_Longint *	weights,
		SCIP_Real *	profits,
		SCIP_Longint	capacity,
		int *	items,
		int *	solitems,
		int *	nonsolitems,
		int *	nsolitems,
		int *	nnonsolitems,
		SCIP_Real *	solval,
		SCIP_Bool *	success )

solves knapsack problem in maximization form exactly using dynamic programming; if needed, one can provide arrays to store all selected items and all not selected items

Note

in case you provide the solitems or nonsolitems array you also have to provide the counter part, as well

the algorithm will first compute a greedy solution and terminate if the greedy solution is proven to be optimal. The dynamic programming algorithm runs with a time and space complexity of O(nitems * capacity).

solves knapsack problem in maximization form exactly using dynamic programming; if needed, one can provide arrays to store all selected items and all not selected items

Note

in case you provide the solitems or nonsolitems array you also have to provide the counter part, as well

the algorithm will first compute a greedy solution and terminate if the greedy solution is proven to be optimal. The dynamic programming algorithm runs with a time and space complexity of O(nitems * capacity).

Parameters

scip	SCIP data structure
nitems	number of available items
weights	item weights
profits	item profits
capacity	capacity of knapsack
items	item numbers
solitems	array to store items in solution, or NULL
nonsolitems	array to store items not in solution, or NULL
nsolitems	pointer to store number of items in solution, or NULL
nnonsolitems	pointer to store number of items not in solution, or NULL
solval	pointer to store optimal solution value, or NULL
success	pointer to store if an error occured during solving (normally a memory problem)

Definition at line 1090 of file cons_knapsack.c.

References assert(), FALSE, i, IDX, MAX, NULL, SCIP_Bool, SCIP_CALL, SCIP_Longint, SCIP_LONGINT_FORMAT, SCIP_LONGINT_MAX, SCIP_NOMEMORY, SCIP_OKAY, SCIP_Real, SCIPallocBufferArray, SCIPcalcGreComDiv(), SCIPdebugMsg, SCIPfloor(), SCIPfreeBufferArray, SCIPisGE(), SCIPisIntegral(), SCIPselectWeightedDownRealLongRealInt(), SCIPsortDownRealIntLong(), and TRUE.

Referenced by dualPresolving(), and getHighestCapacityUsage().

SCIPsolveKnapsackApproximately()

SCIP_RETCODE SCIPsolveKnapsackApproximately	(	SCIP *	scip,
		int	nitems,
		SCIP_Longint *	weights,
		SCIP_Real *	profits,
		SCIP_Longint	capacity,
		int *	items,
		int *	solitems,
		int *	nonsolitems,
		int *	nsolitems,
		int *	nnonsolitems,
		SCIP_Real *	solval )

solves knapsack problem in maximization form approximately by solving the LP-relaxation of the problem using Dantzig's method and rounding down the solution; if needed, one can provide arrays to store all selected items and all not selected items

Parameters

scip	SCIP data structure
nitems	number of available items
weights	item weights
profits	item profits
capacity	capacity of knapsack
items	item numbers
solitems	array to store items in solution, or NULL
nonsolitems	array to store items not in solution, or NULL
nsolitems	pointer to store number of items in solution, or NULL
nnonsolitems	pointer to store number of items not in solution, or NULL
solval	pointer to store optimal solution value, or NULL

Definition at line 1594 of file cons_knapsack.c.

References assert(), NULL, SCIP_CALL, SCIP_Longint, SCIP_OKAY, SCIP_Real, SCIPallocBufferArray, SCIPfreeBufferArray, and SCIPselectWeightedDownRealLongRealInt().

Referenced by getCover().

SCIPseparateKnapsackCuts()

SCIP_RETCODE SCIPseparateKnapsackCuts	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SEPA *	sepa,
		SCIP_VAR **	vars,
		int	nvars,
		SCIP_Longint *	weights,
		SCIP_Longint	capacity,
		SCIP_SOL *	sol,
		SCIP_Bool	usegubs,
		SCIP_Bool *	cutoff,
		int *	ncuts )

separates different classes of valid inequalities for the 0-1 knapsack problem

Parameters

scip	SCIP data structure
cons	originating constraint of the knapsack problem, or NULL
sepa	originating separator of the knapsack problem, or NULL
vars	variables in knapsack constraint
nvars	number of variables in knapsack constraint
weights	weights of variables in knapsack constraint
capacity	capacity of knapsack
sol	primal SCIP solution to separate, NULL for current LP solution
usegubs	should GUB information be used for separation?
cutoff	pointer to store whether a cutoff has been detected
ncuts	pointer to add up the number of found cuts

Definition at line 5564 of file cons_knapsack.c.

References assert(), cutoff, FALSE, getCover(), getFeasibleSet(), GUBsetCreate(), GUBsetFree(), GUBsetGetCliquePartition(), i, makeCoverMinimal(), SCIP_GUBSet::ngubconss, NULL, nvars, SCIP_Bool, SCIP_CALL, SCIP_Longint, SCIP_LONGINT_FORMAT, SCIP_OKAY, SCIP_Real, SCIPallocBufferArray, SCIPconsGetName(), SCIPdebugMsg, SCIPdebugMsgPrint, SCIPfreeBufferArray, SCIPgetSolVals(), SCIPincConsAge(), SCIPvarGetName(), separateSequLiftedMinimalCoverInequality(), separateSupLiftedMinimalCoverInequality(), sol, TRUE, USESUPADDLIFT, and vars.

Referenced by SCIPseparateRelaxedKnapsack(), and separateCons().

SCIPseparateRelaxedKnapsack()

SCIP_RETCODE SCIPseparateRelaxedKnapsack	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SEPA *	sepa,
		int	nknapvars,
		SCIP_VAR **	knapvars,
		SCIP_Real *	knapvals,
		SCIP_Real	valscale,
		SCIP_Real	rhs,
		SCIP_SOL *	sol,
		SCIP_Bool *	cutoff,
		int *	ncuts )

Parameters

scip	SCIP data structure
cons	originating constraint of the knapsack problem, or NULL
sepa	originating separator of the knapsack problem, or NULL
nknapvars	number of variables in the continuous knapsack constraint
knapvars	variables in the continuous knapsack constraint
knapvals	coefficients of the variables in the continuous knapsack constraint
valscale	-1.0 if lhs of row is used as rhs of c. k. constraint, +1.0 otherwise
rhs	right hand side of the continuous knapsack constraint
sol	primal CIP solution, NULL for current LP solution
cutoff	pointer to store whether a cutoff was found
ncuts	pointer to add up the number of found cuts

Definition at line 5781 of file cons_knapsack.c.

References assert(), BMSclearMemoryArray, CONSHDLR_NAME, cutoff, DEFAULT_USEGUBS, FALSE, i, KNAPSACKRELAX_MAXDELTA, KNAPSACKRELAX_MAXDNOM, KNAPSACKRELAX_MAXSCALE, MAXABSVBCOEF, NULL, REALABS, SCIP_Bool, SCIP_CALL, SCIP_Longint, SCIP_LONGINT_FORMAT, SCIP_OKAY, SCIP_Real, SCIPallocBufferArray, SCIPcalcIntegralScalar(), SCIPconsGetName(), SCIPconshdlrGetData(), SCIPdebug, SCIPdebugMsg, SCIPdebugMsgPrint, SCIPdebugPrintCons, SCIPepsilon(), SCIPfeasFloor(), SCIPfindConshdlr(), SCIPfloor(), SCIPfreeBufferArray, SCIPgetNContVars(), SCIPgetNegatedVar(), SCIPgetNVars(), SCIPgetSolVal(), SCIPgetVars(), SCIPisFeasGT(), SCIPisFeasLT(), SCIPisGE(), SCIPisGT(), SCIPisInfinity(), SCIPisLE(), SCIPisLT(), SCIPreallocBlockMemoryArray, SCIPseparateKnapsackCuts(), SCIPvarGetLbGlobal(), SCIPvarGetLbLocal(), SCIPvarGetName(), SCIPvarGetNVlbs(), SCIPvarGetNVubs(), SCIPvarGetProbindex(), SCIPvarGetUbGlobal(), SCIPvarGetUbLocal(), SCIPvarGetVlbCoefs(), SCIPvarGetVlbConstants(), SCIPvarGetVlbVars(), SCIPvarGetVubCoefs(), SCIPvarGetVubConstants(), SCIPvarGetVubVars(), SCIPvarIsActive(), SCIPvarIsBinary(), sol, TRUE, and var.

Referenced by addCut(), and separateCons().

SCIPcleanupConssKnapsack()

SCIP_RETCODE SCIPcleanupConssKnapsack	(	SCIP *	scip,
		SCIP_Bool	onlychecked,
		SCIP_Bool *	infeasible,
		int *	ndelconss )

cleans up (multi-)aggregations and fixings from knapsack constraints

Parameters

scip	SCIP data structure
onlychecked	should only checked constraints be cleaned up?
infeasible	pointer to return whether the problem was detected to be infeasible
ndelconss	pointer to count number of deleted constraints

Definition at line 14027 of file cons_knapsack.c.

References applyFixings(), assert(), CONSHDLR_NAME, FALSE, i, NULL, nvars, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIPconsGetData(), SCIPconshdlrGetCheckConss(), SCIPconshdlrGetConss(), SCIPconshdlrGetNActiveConss(), SCIPconshdlrGetNCheckConss(), SCIPdelCons(), and SCIPfindConshdlr().

Referenced by SCIPmatrixCreate().

SCIPincludeLinconsUpgrade()

SCIP_RETCODE SCIPincludeLinconsUpgrade	(	SCIP *	scip,
		SCIP_DECL_LINCONSUPGD((*linconsupgd))	,
		int	priority,
		const char *	conshdlrname )

includes a linear constraint update method into the linear constraint handler

Parameters

scip	SCIP data structure
priority	priority of upgrading method
conshdlrname	name of the constraint handler

Definition at line 17703 of file cons_linear.c.

References SCIP_LinConsUpgrade::active, assert(), CONSHDLR_NAME, conshdlrdataHasUpgrade(), conshdlrdataIncludeUpgrade(), FALSE, linconsupgradeCreate(), NULL, paramname, SCIP_CALL, SCIP_MAXSTRLEN, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIPaddBoolParam(), SCIPconshdlrGetData(), SCIPerrorMessage, SCIPfindConshdlr(), SCIPsnprintf(), and TRUE.

Referenced by SCIPincludeConshdlrIndicator(), SCIPincludeConshdlrKnapsack(), SCIPincludeConshdlrLogicor(), SCIPincludeConshdlrSetppc(), SCIPincludeConshdlrVarbound(), and SCIPincludeConshdlrXor().

SCIPcreateConsLinear()

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 )

creates and captures a linear constraint

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nvars	number of nonzeros in the constraint
vars	array with variables of constraint entries
vals	array with coefficients of constraint entries
lhs	left hand side of constraint
rhs	right hand side of constraint
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 17755 of file cons_linear.c.

References assert(), consdataCreate(), CONSHDLR_NAME, i, NULL, nvars, propagate, REALABS, SCIP_Bool, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIP_Real, SCIP_STAGE_EXITPRESOLVE, SCIPABORT, SCIPcreateCons(), SCIPduplicateBufferArray, SCIPerrorMessage, SCIPfindConshdlr(), SCIPfreeBufferArray, SCIPgetProbvarLinearSum(), SCIPgetStage(), SCIPinfinity(), SCIPisFinite, SCIPisInfinity(), SCIPreallocBufferArray, SCIPvarGetName(), SCIPvarIsRelaxationOnly(), separate(), and vars.

Referenced by addBranchingComplementaritiesSOS1(), addExtendedAsymmetricFormulation(), addExtendedFlowFormulation(), addLocalBranchingConstraint(), addLocalBranchingConstraint(), addLocalbranchingConstraintAndObjcutoff(), addLocalConss(), addOrbitopesDynamic(), addSSTConssOrbitAndUpdateSST(), addStrongSBCsSubgroup(), addTrustRegionConstraints(), addWeakSBCsSubgroup(), aggregateConstraints(), aggregation(), applyFixings(), applyFixings(), applyFixings(), applyFixings(), applyObbtBilinear(), cancelRow(), consdataLinearize(), copyCuts(), CREATE_CONSTRAINT(), createAndAddConflictCon(), createAndAddLinearCons(), createAndAddProofcons(), createConstraint(), createConstraints(), createCoveringProblem(), createLinearCons(), createMipCpFormulation(), createNAryBranch(), createProbOnlyEdge(), createProbSimplified(), createProbSimplifiedTest(), createRows(), createRows(), createSubSCIP(), createSubscip(), dualPresolve(), execmain(), fixDeleteOrUpgradeCons(), fixVariableZeroNode(), fixVariableZeroNode(), fixVariableZeroNode(), forbidCover(), getFixedVariable(), handleDoubleLexOrbitope(), handleOrbitope(), preprocessConstraintPairs(), propIndicator(), scipexamples::QueensSolver::QueensSolver(), rangedRowPropagation(), readCnf(), readConstraints(), readConstraints(), readConstraints(), readOPBFile(), readRows(), SCIP_DECL_BRANCHEXECLP(), SCIP_DECL_CONFLICTEXEC(), SCIP_DECL_CONSCOPY(), SCIP_DECL_CONSCOPY(), SCIP_DECL_CONSINITPRE(), SCIP_DECL_CONSINITPRE(), SCIP_DECL_CONSPARSE(), SCIP_DECL_CONSPRESOL(), SCIP_DECL_NONLINCONSUPGD(), SCIP_DECL_READERREAD(), SCIPaddTrustregionNeighborhoodConstraint(), SCIPcopyConsExactLinear(), SCIPcopyConsLinear(), SCIPcreateConsBasicLinear(), SCIPcreateConsIndicatorGeneric(), SCIPgetVarCopy(), selectVarMultAggrBranching(), setupAndSolveSubscip(), setupSubproblem(), setupSubScip(), setupSubScip(), tightenSingleVar(), tryAddOrbitalRedLexRed(), tryUpgradingLogicor(), tryUpgradingSetppc(), and upgradeLinearSuperindicator().

SCIPcreateConsBasicLinear()

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 )

creates and captures a linear constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsLinear(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h

See also

SCIPcreateConsLinear() for information about the basic constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nvars	number of nonzeros in the constraint
vars	array with variables of constraint entries
vals	array with coefficients of constraint entries
lhs	left hand side of constraint
rhs	right hand side of constraint

Definition at line 17912 of file cons_linear.c.

References assert(), FALSE, NULL, nvars, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPcreateConsLinear(), TRUE, and vars.

Referenced by addAuxiliaryVariablesToMaster(), addLocalBranchingConstraint(), addLocalBranchingConstraint(), addUseConstraint(), applyRepair(), createAndAddTransferredCut(), createAndApplyStoredBendersCut(), createBlockproblem(), createKKTComplementarityBinary(), createKKTComplementarityBounds(), createKKTComplementarityLinear(), createKKTDualCons(), createMasterproblem(), createMIP(), createMipFormulation(), createOriginalproblem(), createProbSimplified(), createProbSimplifiedTest(), createSubproblem(), createSubproblems(), generateAndApplyBendersCuts(), generateAndApplyBendersIntegerCuts(), generateAndApplyBendersNogoodCut(), getBinaryProductExprDo(), main(), AMPLProblemHandler::OnHeader(), readLIBSVM(), reformulateFactorizedBinaryQuadratic(), SCIP_DECL_HEUREXEC(), SCIP_DECL_PRESOLEXEC(), SCIPapplyProximity(), SCIPbendersMergeSubproblemIntoMaster(), SCIPgenerateAndApplyBendersOptCut(), SCIPverifyCircularPatternNLP(), setupAndSolveFiniteSolSubscip(), setupProblem(), setupProblem(), setupProblem(), setupProblem(), setupProblem(), and solvePricingMINLP().

SCIPcopyConsLinear()

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 )

creates by copying and captures a linear constraint

Parameters

scip	target SCIP data structure
cons	pointer to store the created target constraint
sourcescip	source SCIP data structure
name	name of constraint
nvars	number of variables in source variable array
sourcevars	source variables of the linear constraints
sourcecoefs	coefficient array of the linear constraint, or NULL if all coefficients are one
lhs	left hand side of the linear constraint
rhs	right hand side of the linear constraint
varmap	a SCIP_HASHMAP mapping variables of the source SCIP to corresponding variables of the target SCIP
consmap	a hashmap to store the mapping of source constraints to the corresponding target constraints
initial	should the LP relaxation of constraint be in the initial LP?
separate	should the constraint be separated during LP processing?
enforce	should the constraint be enforced during node processing?
check	should the constraint be checked for feasibility?
propagate	should the constraint be propagated during node processing?
local	is constraint only valid locally?
modifiable	is constraint modifiable (subject to column generation)?
dynamic	is constraint subject to aging?
removable	should the relaxation be removed from the LP due to aging or cleanup?
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node?
global	create a global or a local copy?
valid	pointer to store if the copying was valid

Definition at line 17932 of file cons_linear.c.

References assert(), FALSE, NULL, nvars, propagate, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPallocBufferArray, SCIPcreateConsLinear(), SCIPduplicateBufferArray, SCIPfreeBufferArray, SCIPgetProbvarLinearSum(), SCIPgetVarCopy(), SCIPisGT(), SCIPisInfinity(), SCIPreallocBufferArray, SCIPvarGetOrigvarSum(), SCIPvarIsOriginal(), SCIPvarIsRelaxationOnly(), separate(), TRUE, valid, var, and vars.

Referenced by SCIP_DECL_CONSCOPY(), SCIP_DECL_CONSCOPY(), SCIP_DECL_CONSCOPY(), SCIP_DECL_CONSCOPY(), and SCIP_DECL_CONSCOPY().

SCIPaddCoefLinear()

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

adds coefficient to linear constraint (if it is not zero)

Parameters

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

Definition at line 18064 of file cons_linear.c.

References addCoef(), assert(), chgLhs(), chgRhs(), CONSHDLR_NAME, NULL, REALABS, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_Real, SCIP_STAGE_EXITPRESOLVE, SCIPABORT, SCIPallocBufferArray, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconshdlrGetName(), SCIPerrorMessage, SCIPfreeBufferArray, SCIPgetProbvarLinearSum(), SCIPgetStage(), SCIPinfinity(), SCIPisFinite, SCIPisInfinity(), SCIPisZero(), SCIPreallocBufferArray, SCIPvarGetName(), and var.

Referenced by ObjPricerVRP::add_tour_variable(), addAuxiliaryVariablesToMaster(), addAuxiliaryVariableToCut(), addCoefTerm(), AMPLProblemHandler::LinearPartHandler::AddTerm(), addVariable(), applyFixings(), applyRepair(), computeNogoodCut(), computeStandardIntegerOptCut(), consdataLinearize(), createAndAddLinearCons(), createAndAddProofcons(), createAndAddTransferredCut(), createConstraint(), createKKTComplementarityBinary(), createKKTComplementarityBounds(), createKKTComplementarityLinear(), createKKTDualCons(), createMasterproblem(), createMIP(), createMipCpFormulation(), createMipFormulation(), createOriginalproblem(), createProbOnlyEdge(), createProbSimplified(), createProbSimplifiedTest(), createSubproblem(), createSubproblems(), createSubSCIP(), execmain(), getBoundConsFromVertices(), main(), presolveAddKKTLinearCons(), presolveAddKKTQuadBilinearTerms(), presolveAddKKTQuadLinearTerms(), presolveAddKKTQuadQuadraticTerms(), scipexamples::QueensSolver::QueensSolver(), readCols(), reformulateFactorizedBinaryQuadratic(), SCIP_DECL_CONSINITPRE(), SCIP_DECL_NONLINCONSUPGD(), SCIP_DECL_PRESOLEXEC(), SCIP_DECL_READERREAD(), SCIPaddCoefPseudoboolean(), SCIPaddVarIndicator(), SCIPapplyProximity(), SCIPbendersMergeSubproblemIntoMaster(), SCIPchgCoefLinear(), SCIPconsAddCoef(), SCIPcreateConsIndicatorGeneric(), SCIPcreateConsIndicatorGenericLinConsPure(), SCIPgenerateAndApplyBendersOptCut(), SCIPgetVarCopy(), SCIPverifyCircularPatternNLP(), setupAndSolveFiniteSolSubscip(), setupAndSolveSubscip(), setupProblem(), setupProblem(), setupProblem(), setupProblem(), setupProblem(), setupSubproblem(), setupSubScip(), setupSubScip(), solvePricingMINLP(), tightenSingleVar(), tryUpgradingLogicor(), and tryUpgradingSetppc().

SCIPchgCoefLinear()

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

changes coefficient of variable in linear constraint; deletes the variable if coefficient is zero; adds variable if not yet contained in the constraint

Note

This method may only be called during problem creation stage for an original constraint and variable.

This method requires linear time to search for occurences of the variable in the constraint data.

Parameters

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

Definition at line 18238 of file cons_linear.c.

References assert(), chgCoefPos(), CONSHDLR_NAME, delCoefPos(), FALSE, i, NULL, nvars, SCIP_Bool, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_Real, SCIP_STAGE_PROBLEM, SCIPaddCoefLinear(), SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPconsIsOriginal(), SCIPerrorMessage, SCIPgetStage(), SCIPisZero(), SCIPvarIsOriginal(), TRUE, var, and vars.

Referenced by addScenarioVarsAndConsToProb(), and SCIPdelCoefLinear().

SCIPdelCoefLinear()

SCIP_RETCODE SCIPdelCoefLinear	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var )

deletes variable from linear constraint

Note

This method may only be called during problem creation stage for an original constraint and variable.

This method requires linear time to search for occurences of the variable in the constraint data.

Parameters

scip	SCIP data structure
cons	constraint data
var	variable of constraint entry

Definition at line 18306 of file cons_linear.c.

References assert(), NULL, SCIP_CALL, SCIP_OKAY, SCIPchgCoefLinear(), and var.

SCIPgetLhsLinear()

SCIP_Real SCIPgetLhsLinear	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets left hand side of linear constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 18322 of file cons_linear.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_INVALID, SCIP_Real, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by addAltLPConstraint(), addLinearConstraints(), addScenarioVarsAndConsToProb(), addSymmetryInformation(), checkConsnames(), checkConsnames(), checkConsnames(), checkLinearConssVarboundSOS1(), computeNogoodCut(), computeStandardIntegerOptCut(), createAltLP(), createAltLP(), createAndAddProofcons(), generateAndApplyBendersCuts(), generateAndApplyBendersIntegerCuts(), getLinearConsSides(), matrixCreate(), presolveAddKKTLinearConss(), presolveAddKKTQuadLinearTerms(), printRangeSection(), propIndicator(), readIndicators(), readQCMatrix(), readRanges(), readRhs(), reuseSolution(), reuseSolution(), saveConsLinear(), SCIP_DECL_CONSCOPY(), SCIP_DECL_CONSLOCK(), SCIP_DECL_CONSPARSE(), SCIP_DECL_PRESOLEXEC(), SCIPconflictstoreCleanNewIncumbent(), SCIPconsGetLhs(), SCIPcreateConsIndicatorGenericLinConsPure(), SCIPgenerateAndApplyBendersOptCut(), SCIPgetDualSolVal(), SCIPmakeIndicatorFeasible(), SCIPmatrixCreate(), SCIPwriteGms(), SCIPwriteLp(), SCIPwriteMps(), SCIPwritePip(), separatePerspective(), tightenVarsBoundsSOS1(), upgradeIndicatorSuperindicator(), upgradeLinearSuperindicator(), writeFzn(), and writeOpbConstraints().

SCIPgetRhsLinear()

SCIP_Real SCIPgetRhsLinear	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets right hand side of linear constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 18346 of file cons_linear.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_INVALID, SCIP_Real, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by addAltLPConstraint(), addLinearConstraints(), addScenarioVarsAndConsToProb(), addSymmetryInformation(), checkConsnames(), checkConsnames(), checkLinearConssVarboundSOS1(), createAltLP(), createAltLP(), createAndAddProofcons(), generateAndApplyBendersCuts(), getLinearConsSides(), matrixCreate(), presolveAddKKTLinearConss(), presolveAddKKTQuadLinearTerms(), printRangeSection(), propIndicator(), readIndicators(), readQCMatrix(), readRanges(), readRhs(), reuseSolution(), reuseSolution(), saveConsLinear(), SCIP_DECL_CONSCOPY(), SCIP_DECL_CONSLOCK(), SCIP_DECL_CONSPARSE(), SCIP_DECL_CONSPROP(), SCIP_DECL_PRESOLEXEC(), SCIPapplyProximity(), SCIPconflictstoreCleanNewIncumbent(), SCIPconsGetRhs(), SCIPcreateConsIndicatorGenericLinConsPure(), SCIPgetDualSolVal(), SCIPmakeIndicatorFeasible(), SCIPmatrixCreate(), SCIPwriteGms(), SCIPwriteLp(), SCIPwriteMps(), SCIPwritePip(), separatePerspective(), tightenVarsBoundsSOS1(), upgradeIndicatorSuperindicator(), upgradeLinearSuperindicator(), writeFzn(), writeOpbConstraints(), and writeOpbObjective().

SCIPchgLhsLinear()

SCIP_RETCODE SCIPchgLhsLinear	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Real	lhs )

changes left hand side of linear constraint

Parameters

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

Definition at line 18370 of file cons_linear.c.

References assert(), chgLhs(), CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_Real, SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by addScenarioVarsAndConsToProb(), applyFixings(), chgLhsLinearCons(), computeNogoodCut(), computeStandardIntegerOptCut(), fixDiscreteVars(), generateAndApplyBendersIntegerCuts(), initCurrent(), AMPLProblemHandler::OnConBounds(), presolveAddKKTQuadLinearTerms(), readIndicators(), readRanges(), readRhs(), SCIP_DECL_HEUREXEC(), SCIP_DECL_PRESOLEXEC(), SCIPconflictstoreCleanNewIncumbent(), tryUpgradingLogicor(), and updatePartition().

SCIPchgRhsLinear()

SCIP_RETCODE SCIPchgRhsLinear	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Real	rhs )

changes right hand side of linear constraint

Parameters

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

Definition at line 18391 of file cons_linear.c.

References chgRhs(), CONSHDLR_NAME, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_Real, SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by addScenarioVarsAndConsToProb(), applyFixings(), chgRhsLinearCons(), fixDiscreteVars(), initCurrent(), AMPLProblemHandler::OnConBounds(), presolveAddKKTQuadLinearTerms(), readRanges(), readRhs(), SCIP_DECL_HEUREXEC(), SCIP_DECL_PRESOLEXEC(), SCIPapplyHeurDualval(), SCIPapplyProximity(), SCIPconflictstoreCleanNewIncumbent(), tryUpgradingSetppc(), and updatePartition().

SCIPgetNVarsLinear()

int SCIPgetNVarsLinear	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets the number of variables in the linear constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 18409 of file cons_linear.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by addAltLPConstraint(), addLinearConstraints(), addSymmetryInformation(), addSymmetryInformation(), checkLinearConssVarboundSOS1(), checkTrivialInfeas(), createAltLP(), createAltLP(), extractLinearValues(), SCIPNLFeeder::FeedLinearConExpr(), getLinearConsNVars(), getLinearConsVarsData(), getNVarsIndicators(), matrixCreate(), presolveAddKKTLinearConss(), propIndicator(), readIndicators(), readQCMatrix(), SCIP_DECL_CONSCOPY(), SCIP_DECL_CONSLOCK(), SCIP_DECL_CONSPRESOL(), SCIP_DECL_CONSPROP(), SCIP_DECL_CONSRESPROP(), SCIPcreateConsIndicatorGenericLinCons(), SCIPcreateConsIndicatorGenericLinConsPure(), SCIPiisGenerate(), SCIPmakeIndicatorFeasible(), SCIPmatrixCreate(), SCIPsetLinearConsIndicator(), SCIPwriteCcg(), SCIPwriteGms(), SCIPwriteLp(), SCIPwriteMps(), SCIPwritePbm(), SCIPwritePip(), SCIPwritePpm(), separatePerspective(), tightenVarsBoundsSOS1(), upgradeIndicatorSuperindicator(), upgradeLinearSuperindicator(), writeFzn(), writeOpbConstraints(), and writeOpbObjective().

SCIPgetVarsLinear()

SCIP_VAR ** SCIPgetVarsLinear	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets the array of variables in the linear constraint; the user must not modify this array!

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 18433 of file cons_linear.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by addAltLPConstraint(), addLinearConstraints(), addSymmetryInformation(), addSymmetryInformation(), checkLinearConssVarboundSOS1(), checkTrivialInfeas(), createAltLP(), createAltLP(), extractLinearValues(), SCIPNLFeeder::FeedLinearConExpr(), getLinearConsVarsData(), getNVarsIndicators(), matrixCreate(), presolveAddKKTLinearConss(), propIndicator(), readIndicators(), readQCMatrix(), saveConsLinear(), SCIP_DECL_CONSCOPY(), SCIP_DECL_CONSLOCK(), SCIP_DECL_CONSPRESOL(), SCIP_DECL_CONSPROP(), SCIP_DECL_CONSRESPROP(), SCIPcreateConsIndicatorGenericLinCons(), SCIPcreateConsIndicatorGenericLinConsPure(), SCIPgetDualSolVal(), SCIPiisGenerate(), SCIPmakeIndicatorFeasible(), SCIPmatrixCreate(), SCIPsetLinearConsIndicator(), SCIPwriteCcg(), SCIPwriteGms(), SCIPwriteLp(), SCIPwriteMps(), SCIPwritePbm(), SCIPwritePip(), SCIPwritePpm(), separatePerspective(), tightenVarsBoundsSOS1(), upgradeIndicatorSuperindicator(), upgradeLinearSuperindicator(), writeFzn(), writeOpbConstraints(), and writeOpbObjective().

SCIPgetValsLinear()

SCIP_Real * SCIPgetValsLinear	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets the array of coefficient values in the linear constraint; the user must not modify this array!

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 18457 of file cons_linear.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_Real, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by addAltLPConstraint(), addLinearConstraints(), addSymmetryInformation(), addSymmetryInformation(), checkLinearConssVarboundSOS1(), checkTrivialInfeas(), createAltLP(), createAltLP(), extractLinearValues(), SCIPNLFeeder::FeedLinearConExpr(), getLinearConsVarsData(), matrixCreate(), presolveAddKKTLinearConss(), propIndicator(), readIndicators(), readQCMatrix(), saveConsLinear(), SCIP_DECL_CONSCOPY(), SCIP_DECL_CONSLOCK(), SCIP_DECL_CONSPRESOL(), SCIP_DECL_CONSPROP(), SCIP_DECL_CONSRESPROP(), SCIPcreateConsIndicatorGenericLinConsPure(), SCIPgetConsVals(), SCIPgetDualSolVal(), SCIPmakeIndicatorFeasible(), SCIPmatrixCreate(), SCIPwriteCcg(), SCIPwriteGms(), SCIPwriteLp(), SCIPwriteMps(), SCIPwritePbm(), SCIPwritePip(), SCIPwritePpm(), separatePerspective(), tightenVarsBoundsSOS1(), upgradeIndicatorSuperindicator(), upgradeLinearSuperindicator(), writeFzn(), and writeOpbConstraints().

SCIPgetActivityLinear()

SCIP_Real SCIPgetActivityLinear	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SOL *	sol )

gets the activity of the linear constraint in the given solution

Note

if the solution contains values at infinity, this method will return SCIP_INVALID in case the activity comprises positive and negative infinity contributions

Parameters

scip	SCIP data structure
cons	constraint data
sol	solution, or NULL to use current node's solution

Definition at line 18485 of file cons_linear.c.

References assert(), consdataGetActivity(), CONSHDLR_NAME, NULL, SCIP_INVALID, SCIP_Real, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPerrorMessage, SCIPgetRowSolActivity(), and sol.

Referenced by computeNogoodCut(), computeStandardIntegerOptCut(), generateAndApplyBendersCuts(), reuseSolution(), and SCIPgenerateAndApplyBendersOptCut().

SCIPgetFeasibilityLinear()

SCIP_Real SCIPgetFeasibilityLinear	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SOL *	sol )

gets the feasibility of the linear constraint in the given solution

Parameters

scip	SCIP data structure
cons	constraint data
sol	solution, or NULL to use current node's solution

Definition at line 18513 of file cons_linear.c.

References assert(), consdataGetFeasibility(), CONSHDLR_NAME, NULL, SCIP_INVALID, SCIP_Real, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPerrorMessage, SCIPgetRowSolFeasibility(), and sol.

SCIPgetDualsolLinear()

SCIP_Real SCIPgetDualsolLinear	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets the dual solution of the linear constraint in the current LP

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 18541 of file cons_linear.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_INVALID, SCIP_Real, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPconsIsOriginal(), SCIPerrorMessage, and SCIProwGetDualsol().

Referenced by ObjPricerVRP::pricing(), SCIP_DECL_EVENTEXEC(), SCIP_DECL_PRICERREDCOST(), SCIPconsGetDualsol(), SCIPgetDualSolVal(), and SCIPwriteSolutionNl().

SCIPgetDualfarkasLinear()

SCIP_Real SCIPgetDualfarkasLinear	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets the dual Farkas value of the linear constraint in the current infeasible LP

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 18569 of file cons_linear.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_INVALID, SCIP_Real, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPconsIsOriginal(), SCIPerrorMessage, and SCIProwGetDualfarkas().

Referenced by ObjPricerVRP::pricing(), and SCIPconsGetDualfarkas().

SCIPgetRowLinear()

SCIP_ROW * SCIPgetRowLinear	(	SCIP *	scip,
		SCIP_CONS *	cons )

returns the linear relaxation of the given linear constraint; may return NULL if no LP row was yet created; the user must not modify the row!

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 18599 of file cons_linear.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by SCIPconsCreateRow(), and SCIPconsGetRow().

SCIPcreateRowLinear()

SCIP_RETCODE SCIPcreateRowLinear	(	SCIP *	scip,
		SCIP_CONS *	cons )

creates and returns the row of the given linear constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 18623 of file cons_linear.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_ERROR, SCIP_OKAY, SCIPABORT, SCIPaddVarsToRow(), SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconshdlrGetName(), SCIPconsIsLocal(), SCIPconsIsModifiable(), SCIPconsIsRemovable(), SCIPcreateEmptyRowCons(), and SCIPerrorMessage.

Referenced by SCIPconsCreateRow().

SCIPupgradeConsLinear()

SCIP_RETCODE SCIPupgradeConsLinear	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_CONS **	upgdcons )

tries to automatically convert a linear constraint into a more specific and more specialized constraint

Parameters

scip	SCIP data structure
cons	source constraint to try to convert
upgdcons	pointer to store upgraded constraint, or NULL if not successful

Definition at line 18652 of file cons_linear.c.

References assert(), CONSHDLR_NAME, i, normalizeCons(), NULL, SCIP_Bool, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_Real, SCIP_VARTYPE_BINARY, SCIP_VARTYPE_CONTINUOUS, SCIP_VARTYPE_INTEGER, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconsGetNUpgradeLocks(), SCIPconshdlrGetData(), SCIPconshdlrGetName(), SCIPconsIsModifiable(), SCIPdebugMsg, SCIPdebugPrintCons, SCIPerrorMessage, SCIPisEQ(), SCIPisIntegral(), SCIPisPositive(), SCIPisZero(), SCIPreleaseRow(), SCIProwIsInLP(), SCIPvarGetLbLocal(), SCIPvarGetType(), SCIPvarGetUbLocal(), SCIPvarIsBinary(), SCIPvarIsImpliedIntegral(), tightenSides(), TRUE, and var.

Referenced by createAndAddConflictCon(), createAndAddProofcons(), SCIP_DECL_CONFLICTEXEC(), and SCIP_DECL_CONSPRESOL().

SCIPclassifyConstraintTypesLinear()

SCIP_RETCODE SCIPclassifyConstraintTypesLinear	(	SCIP *	scip,
		SCIP_LINCONSSTATS *	linconsstats )

performs linear constraint type classification as used for MIPLIB

iterates through all linear constraints and stores relevant statistics in the linear constraint statistics linconsstats.

Note

only constraints are iterated that belong to the linear constraint handler. If the problem has been presolved already, constraints that were upgraded to more special types such as, e.g., varbound constraints, will not be shown correctly anymore. Similarly, if specialized constraints were created through the API, these are currently not present.

Parameters

scip	SCIP data structure
linconsstats	linear constraint type classification

Definition at line 15231 of file cons_linear.c.

References assert(), b, c, CONSHDLR_NAME, FALSE, i, isFiniteNonnegativeIntegral(), isRangedRow(), mergeMultiples(), NULL, REALABS, SCIP_Bool, SCIP_CALL, SCIP_LINCONSTYPE_AGGREGATION, SCIP_LINCONSTYPE_BINPACKING, SCIP_LINCONSTYPE_CARDINALITY, SCIP_LINCONSTYPE_EMPTY, SCIP_LINCONSTYPE_EQKNAPSACK, SCIP_LINCONSTYPE_FREE, SCIP_LINCONSTYPE_GENERAL, SCIP_LINCONSTYPE_INTKNAPSACK, SCIP_LINCONSTYPE_INVKNAPSACK, SCIP_LINCONSTYPE_KNAPSACK, SCIP_LINCONSTYPE_MIXEDBINARY, SCIP_LINCONSTYPE_PRECEDENCE, SCIP_LINCONSTYPE_SETCOVERING, SCIP_LINCONSTYPE_SETPACKING, SCIP_LINCONSTYPE_SETPARTITION, SCIP_LINCONSTYPE_SINGLETON, SCIP_LINCONSTYPE_VARBOUND, SCIP_OKAY, SCIP_Real, SCIP_STAGE_PROBLEM, SCIP_VARTYPE_BINARY, SCIP_VARTYPE_CONTINUOUS, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetConss(), SCIPconshdlrGetNConss(), SCIPdebugMsg, SCIPdebugPrintCons, SCIPfindConshdlr(), SCIPgetConss(), SCIPgetNConss(), SCIPgetStage(), SCIPinfinity(), SCIPisEQ(), SCIPisGE(), SCIPisInfinity(), SCIPisIntegral(), SCIPisLE(), SCIPisNegative(), SCIPisZero(), SCIPlinConsStatsIncTypeCount(), SCIPlinConsStatsReset(), SCIPvarGetLbGlobal(), SCIPvarGetType(), SCIPvarGetUbGlobal(), SCIPvarIsIntegral(), and TRUE.

Referenced by SCIP_DECL_DIALOGEXEC().

SCIPcleanupConssLinear()

SCIP_RETCODE SCIPcleanupConssLinear	(	SCIP *	scip,
		SCIP_Bool	onlychecked,
		SCIP_Bool *	infeasible,
		int *	ndelconss )

cleans up (multi-)aggregations and fixings from linear constraints

Parameters

scip	SCIP data structure
onlychecked	should only checked constraints be cleaned up?
infeasible	pointer to return whether the problem was detected to be infeasible
ndelconss	pointer to count number of deleted constraints

Definition at line 18896 of file cons_linear.c.

References applyFixings(), assert(), CONSHDLR_NAME, FALSE, i, NULL, nvars, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIPconsGetData(), SCIPconshdlrGetCheckConss(), SCIPconshdlrGetConss(), SCIPconshdlrGetNActiveConss(), SCIPconshdlrGetNCheckConss(), SCIPdelCons(), and SCIPfindConshdlr().

Referenced by SCIPmatrixCreate().

SCIPcreateConsLinking()

SCIP_RETCODE SCIPcreateConsLinking	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_VAR *	linkvar,
		SCIP_VAR **	binvars,
		SCIP_Real *	vals,
		int	nbinvars,
		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 )

creates and captures a linking constraint

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
linkvar	linking variable (continuous or integer) which should be linked
binvars	binary variables
vals	coefficients of the binary variables
nbinvars	number of binary starting variables
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 3576 of file cons_linking.c.

References assert(), consdataCreate(), consdataCreateBinvars(), CONSHDLR_NAME, getHashmapKey(), HASHSIZE_BINVARSCONS, NULL, propagate, REALABS, SCIP_Bool, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIP_Real, SCIPblkmem(), SCIPconshdlrGetData(), SCIPcreateCons(), SCIPdebugMsg, SCIPerrorMessage, SCIPfindConshdlr(), SCIPgetStage(), SCIPhashmapCreate(), SCIPhashmapExists(), SCIPhashmapInsert(), SCIPisFinite, SCIPisInfinity(), SCIPvarGetLbGlobal(), SCIPvarGetName(), SCIPvarGetUbGlobal(), SCIPvarIsIntegral(), and separate().

Referenced by consdataCollectLinkingCons(), SCIP_DECL_CONSCOPY(), SCIP_DECL_CONSPARSE(), and SCIPcreateConsBasicLinking().

SCIPcreateConsBasicLinking()

SCIP_RETCODE SCIPcreateConsBasicLinking	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_VAR *	linkvar,
		SCIP_VAR **	binvars,
		SCIP_Real *	vals,
		int	nbinvars )

creates and captures a linking constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsLinking(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h

See also

SCIPcreateConsLinking() for information about the basic constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

creates and captures a linking constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsLinking(); all flags can be set via SCIPsetCons<Flagname>-methods in scip.h

See also

SCIPcreateConsLinking() for information about the basic constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
linkvar	linking variable (continuous or integer) which should be linked
binvars	binary variables, or NULL
vals	coefficients of the binary variables
nbinvars	number of binary variables

Definition at line 3690 of file cons_linking.c.

References assert(), FALSE, NULL, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPcreateConsLinking(), and TRUE.

SCIPexistsConsLinking()

SCIP_Bool SCIPexistsConsLinking	(	SCIP *	scip,
		SCIP_VAR *	linkvar )

checks if for the given linking variable (continuous or integer) a linking constraint exists

Parameters

scip	SCIP data structure
linkvar	linking variable (continuous or integer) which should be linked

Definition at line 3709 of file cons_linking.c.

References assert(), CONSHDLR_NAME, getHashmapKey(), NULL, SCIP_Bool, SCIPconshdlrGetData(), SCIPfindConshdlr(), and SCIPhashmapExists().

Referenced by collectBinaryVars(), and consdataCollectLinkingCons().

SCIPgetConsLinking()

SCIP_CONS * SCIPgetConsLinking	(	SCIP *	scip,
		SCIP_VAR *	linkvar )

returns the linking constraint belonging the given linking variable (continuous or integer) or NULL if it does not exist yet

Parameters

scip	SCIP data structure
linkvar	linking variable (continuous or integer) which should be linked

Definition at line 3727 of file cons_linking.c.

References assert(), CONSHDLR_NAME, getHashmapKey(), NULL, SCIPconshdlrGetData(), SCIPfindConshdlr(), and SCIPhashmapGetImage().

Referenced by collectBinaryVars(), consdataCollectLinkingCons(), and consdataCreate().

SCIPgetLinkvarLinking()

SCIP_VAR * SCIPgetLinkvarLinking	(	SCIP *	scip,
		SCIP_CONS *	cons )

returns the linking variable (continuous or integer) of the linking constraint

Parameters

scip	SCIP data structure
cons	linking constraint

Definition at line 3748 of file cons_linking.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

SCIPgetBinvarsLinking()

SCIP_RETCODE SCIPgetBinvarsLinking	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR ***	binvars,
		int *	nbinvars )

returns the binary variables of the linking constraint

Parameters

scip	SCIP data structure
cons	linking constraint
binvars	pointer to store the binary variables array pointer
nbinvars	pointer to store the number of returned binary variables

Definition at line 3771 of file cons_linking.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_INVALIDDATA, SCIP_OKAY, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by collectBinaryVars(), createCoverCutsTimepoint(), and SCIPmatrixCreate().

SCIPgetNBinvarsLinking()

int SCIPgetNBinvarsLinking	(	SCIP *	scip,
		SCIP_CONS *	cons )

returns the number of binary variables of the linking constraint

Parameters

scip	SCIP data structure
cons	linking constraint

Definition at line 3802 of file cons_linking.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

SCIPgetValsLinking()

SCIP_Real * SCIPgetValsLinking	(	SCIP *	scip,
		SCIP_CONS *	cons )

returns the coefficients of the binary variables

Parameters

scip	SCIP data structure
cons	linking constraint

Definition at line 3825 of file cons_linking.c.

References assert(), consdataSort(), CONSHDLR_NAME, NULL, SCIP_Real, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by collectBinaryVars(), createCoverCutsTimepoint(), and SCIPmatrixCreate().

SCIPgetBinvarsDataLinking()

SCIP_RETCODE SCIPgetBinvarsDataLinking	(	SCIP_CONS *	cons,
		SCIP_VAR ***	binvars,
		SCIP_Real **	vals,
		int *	nbinvars )

return all binary variable information of the linking constraint

Parameters

cons	linking constraint
binvars	pointer to store binary variables, or NULL
vals	pointer to store the binary coefficients, or NULL
nbinvars	pointer to store the number of binary variables, or NULL

Definition at line 3849 of file cons_linking.c.

References assert(), consdataSort(), CONSHDLR_NAME, NULL, SCIP_ERROR, SCIP_OKAY, SCIP_Real, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

SCIPcreateConsLogicor()

SCIP_RETCODE SCIPcreateConsLogicor	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nvars,
		SCIP_VAR **	vars,
		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 )

creates and captures a logic or constraint

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nvars	number of variables in the constraint
vars	array with variables of constraint entries
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 5420 of file cons_logicor.c.

References assert(), consdataCreate(), CONSHDLR_NAME, i, NULL, nvars, propagate, SCIP_Bool, SCIP_CALL, SCIP_EVENTTYPE_VARFIXED, SCIP_INVALIDCALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_STAGE_PRESOLVING, SCIPcatchVarEvent(), SCIPconshdlrGetData(), SCIPcreateCons(), SCIPerrorMessage, SCIPfindConshdlr(), SCIPgetStage(), SCIPisTransformed(), SCIPvarGetName(), SCIPvarIsBinary(), separate(), and vars.

Referenced by addSplitcons(), applyCliqueFixings(), BENDERS_CUTORACLE(), BENDERS_CUTORACLE(), consdataLinearize(), createAndAddLinearCons(), createBinaryConstraint(), createConflict(), createConflictCons(), createNormalizedLogicor(), extendToCover(), readCnf(), SCIP_DECL_CONFLICTEXEC(), SCIP_DECL_CONFLICTEXEC(), SCIP_DECL_CONSPARSE(), SCIP_DECL_HEUREXEC(), SCIPcreateConsBasicLogicor(), SCIPreoptApplyGlbConss(), upgradeCons(), and upgradeCons().

SCIPcreateConsBasicLogicor()

SCIP_RETCODE SCIPcreateConsBasicLogicor	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nvars,
		SCIP_VAR **	vars )

creates and captures a logicor constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsLogicor(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h

See also

SCIPcreateConsLogicor() for information about the basic constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nvars	number of variables in the constraint
vars	array with variables of constraint entries

Definition at line 5509 of file cons_logicor.c.

References assert(), FALSE, NULL, nvars, SCIP_CALL, SCIP_OKAY, SCIPcreateConsLogicor(), TRUE, and vars.

Referenced by addFixedVarsConss(), createProbQP(), createProbSimplified(), and createProbSimplifiedTest().

SCIPaddCoefLogicor()

SCIP_RETCODE SCIPaddCoefLogicor	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var )

adds coefficient in logic or constraint

Parameters

scip	SCIP data structure
cons	logicor constraint
var	variable to add to the constraint

Definition at line 5526 of file cons_logicor.c.

References addCoef(), assert(), CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPerrorMessage, and var.

Referenced by addCoefTerm(), createConflictCons(), createProbQP(), createProbSimplified(), createProbSimplifiedTest(), SCIPaddCoefPseudoboolean(), and SCIPconsAddCoef().

SCIPgetNVarsLogicor()

int SCIPgetNVarsLogicor	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets number of variables in logic or constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 5549 of file cons_logicor.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by addLogicOrConstraints(), addSymmetryInformation(), addSymmetryInformation(), checkLogicor(), correctPresoldata(), createAltLP(), createAltLP(), createPresoldata(), extractGates(), SCIPNLFeeder::FeedLinearConExpr(), getLinearConsNVars(), getLinearConsVarsData(), matrixCreate(), presolveAddKKTLogicorConss(), SCIP_DECL_CONSCOPY(), SCIP_DECL_PRESOLEXEC(), SCIPmatrixCreate(), SCIPwriteCcg(), SCIPwriteGms(), SCIPwriteLp(), SCIPwriteMps(), SCIPwritePbm(), SCIPwritePip(), SCIPwritePpm(), writeFzn(), and writeOpbConstraints().

SCIPgetVarsLogicor()

SCIP_VAR ** SCIPgetVarsLogicor	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets array of variables in logic or constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 5572 of file cons_logicor.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by addLogicOrConstraints(), addSymmetryInformation(), addSymmetryInformation(), checkLogicor(), createAltLP(), createAltLP(), extractGates(), SCIPNLFeeder::FeedLinearConExpr(), getLinearConsVarsData(), matrixCreate(), presolveAddKKTLogicorConss(), saveConsLinear(), SCIP_DECL_CONSCOPY(), SCIP_DECL_PRESOLEXEC(), SCIPmatrixCreate(), SCIPwriteCcg(), SCIPwriteGms(), SCIPwriteLp(), SCIPwriteMps(), SCIPwritePbm(), SCIPwritePip(), SCIPwritePpm(), writeFzn(), and writeOpbConstraints().

SCIPgetDualsolLogicor()

SCIP_Real SCIPgetDualsolLogicor	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets the dual solution of the logic or constraint in the current LP

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 5595 of file cons_logicor.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_INVALID, SCIP_Real, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPerrorMessage, and SCIProwGetDualsol().

Referenced by SCIPconsGetDualsol().

SCIPgetDualfarkasLogicor()

SCIP_Real SCIPgetDualfarkasLogicor	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets the dual Farkas value of the logic or constraint in the current infeasible LP

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 5621 of file cons_logicor.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_INVALID, SCIP_Real, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPerrorMessage, and SCIProwGetDualfarkas().

Referenced by SCIPconsGetDualfarkas().

SCIPgetRowLogicor()

SCIP_ROW * SCIPgetRowLogicor	(	SCIP *	scip,
		SCIP_CONS *	cons )

returns the linear relaxation of the given logic or constraint; may return NULL if no LP row was yet created; the user must not modify the row!

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 5649 of file cons_logicor.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by SCIPconsCreateRow(), and SCIPconsGetRow().

SCIPcreateRowLogicor()

SCIP_RETCODE SCIPcreateRowLogicor	(	SCIP *	scip,
		SCIP_CONS *	cons )

creates and returns the row of the given logicor constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 5672 of file cons_logicor.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_ERROR, SCIP_OKAY, SCIPABORT, SCIPaddVarsToRowSameCoef(), SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconshdlrGetName(), SCIPconsIsLocal(), SCIPconsIsModifiable(), SCIPconsIsRemovable(), SCIPcreateEmptyRowCons(), SCIPerrorMessage, and SCIPinfinity().

Referenced by SCIPconsCreateRow().

SCIPcleanupConssLogicor()

SCIP_RETCODE SCIPcleanupConssLogicor	(	SCIP *	scip,
		SCIP_Bool	onlychecked,
		int *	naddconss,
		int *	ndelconss,
		int *	nchgcoefs )

cleans up (multi-)aggregations and fixings from logicor constraints

Parameters

scip	SCIP data structure
onlychecked	should only checked constraints be cleaned up?
naddconss	pointer to count number of added (linear) constraints
ndelconss	pointer to count number of deleted (logicor) constraints
nchgcoefs	pointer to count number of changed coefficients

Definition at line 5701 of file cons_logicor.c.

References applyFixings(), assert(), CONSHDLR_NAME, FALSE, i, mergeMultiples(), NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIPallocBufferArray, SCIPconshdlrGetCheckConss(), SCIPconshdlrGetConss(), SCIPconshdlrGetData(), SCIPconshdlrGetNActiveConss(), SCIPconshdlrGetNCheckConss(), SCIPconsIsDeleted(), SCIPdelCons(), SCIPfindConshdlr(), SCIPfreeBufferArray, SCIPgetNContVars(), and SCIPgetNVars().

Referenced by SCIPmatrixCreate().

SCIPincludeConsUpgradeNonlinear()

SCIP_RETCODE SCIPincludeConsUpgradeNonlinear	(	SCIP *	scip,
		SCIP_DECL_NONLINCONSUPGD((*nlconsupgd))	,
		int	priority,
		SCIP_Bool	active,
		const char *	conshdlrname )

includes a nonlinear constraint upgrade method into the nonlinear constraint handler

Parameters

scip	SCIP data structure
priority	priority of upgrading method
active	should the upgrading method by active by default?
conshdlrname	name of the constraint handler

Definition at line 12728 of file cons_nonlinear.c.

References active, CONSUPGRADE::active, assert(), CONSHDLR_NAME, FALSE, i, NULL, paramname, CONSUPGRADE::priority, SCIP_Bool, SCIP_CALL, SCIP_MAXSTRLEN, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIPaddBoolParam(), SCIPallocBlockMemory, SCIPconshdlrGetData(), SCIPensureBlockMemoryArray, SCIPerrorMessage, SCIPfindConshdlr(), SCIPsnprintf(), and SCIPwarningMessage().

Referenced by SCIPincludeConshdlrLinear(), and SCIPincludeConshdlrSetppc().

SCIPcreateConsNonlinear()

SCIP_RETCODE SCIPcreateConsNonlinear	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_EXPR *	expr,
		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 )

creates and captures a nonlinear constraint

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
expr	expression of constraint (must not be NULL)
lhs	left hand side of constraint
rhs	right hand side of constraint
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.

Definition at line 12799 of file cons_nonlinear.c.

References CONSHDLR_NAME, createCons(), NULL, propagate, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIP_Real, SCIPerrorMessage, SCIPfindConshdlr(), separate(), and TRUE.

Referenced by createConstraint(), readConstraints(), readObjective(), and SCIPcreateConsBasicNonlinear().

SCIPcreateConsBasicNonlinear()

SCIP_RETCODE SCIPcreateConsBasicNonlinear	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_EXPR *	expr,
		SCIP_Real	lhs,
		SCIP_Real	rhs )

creates and captures a nonlinear constraint with all its constraint flags set to their default values

All flags can be set via SCIPconsSetFLAGNAME-methods.

See also

SCIPcreateConsNonlinear() for information about the basic constraint flag configuration.

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
expr	expression of constraint (must not be NULL)
lhs	left hand side of constraint
rhs	right hand side of constraint

Definition at line 12854 of file cons_nonlinear.c.

References FALSE, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPcreateConsNonlinear(), and TRUE.

Referenced by AMPLProblemHandler::EndInput(), AMPLProblemHandler::OnHeader(), AMPLProblemHandler::OnLogicalCon(), SCIPcreateConsBasicSignpowerNonlinear(), SCIPcreateConsBasicSOCNonlinear(), setupProblem(), setupProblem(), and setupProblem().

SCIPcreateConsQuadraticNonlinear()

SCIP_RETCODE SCIPcreateConsQuadraticNonlinear	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nlinvars,
		SCIP_VAR **	linvars,
		SCIP_Real *	lincoefs,
		int	nquadterms,
		SCIP_VAR **	quadvars1,
		SCIP_VAR **	quadvars2,
		SCIP_Real *	quadcoefs,
		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 )

creates and captures a quadratic nonlinear constraint

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nlinvars	number of linear terms
linvars	array with variables in linear part
lincoefs	array with coefficients of variables in linear part
nquadterms	number of quadratic terms
quadvars1	array with first variables in quadratic terms
quadvars2	array with second variables in quadratic terms
quadcoefs	array with coefficients of quadratic terms
lhs	left hand side of quadratic equation
rhs	right hand side of quadratic equation
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.

Definition at line 12873 of file cons_nonlinear.c.

References assert(), CONSHDLR_NAME, createCons(), FALSE, i, NULL, propagate, SCIP_Bool, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIP_Real, SCIPcreateExprQuadratic(), SCIPerrorMessage, SCIPfindConshdlr(), SCIPisFinite, SCIPisInfinity(), SCIPreleaseExpr(), SCIPvarGetName(), and separate().

Referenced by createOriginalproblem(), createProbQP(), createQuadraticCons(), createSubproblems(), readConstraints(), readObjective(), readQCMatrix(), readQMatrix(), SCIPcreateConsBasicQuadraticNonlinear(), SCIPcreateConsIndicatorGeneric(), SCIPcreateConsIndicatorGenericLinCons(), SCIPcreateConsIndicatorGenericLinConsPure(), SCIPverifyCircularPatternNLP(), setupProblem(), setupProblem(), setupProblem(), and solvePricingMINLP().

SCIPcreateConsBasicQuadraticNonlinear()

SCIP_RETCODE SCIPcreateConsBasicQuadraticNonlinear	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nlinvars,
		SCIP_VAR **	linvars,
		SCIP_Real *	lincoefs,
		int	nquadterms,
		SCIP_VAR **	quadvars1,
		SCIP_VAR **	quadvars2,
		SCIP_Real *	quadcoefs,
		SCIP_Real	lhs,
		SCIP_Real	rhs )

creates and captures a quadratic nonlinear constraint with all its constraint flags set to their default values

All flags can be set via SCIPconsSetFLAGNAME-methods.

See also

SCIPcreateConsQuadraticNonlinear() for information about the basic constraint flag configuration.

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nlinvars	number of linear terms
linvars	array with variables in linear part
lincoefs	array with coefficients of variables in linear part
nquadterms	number of quadratic terms
quadvars1	array with first variables in quadratic terms
quadvars2	array with second variables in quadratic terms
quadcoefs	array with coefficients of quadratic terms
lhs	left hand side of quadratic equation
rhs	right hand side of quadratic equation

Definition at line 12964 of file cons_nonlinear.c.

References FALSE, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPcreateConsQuadraticNonlinear(), and TRUE.

SCIPcreateConsBasicSOCNonlinear()

SCIP_RETCODE SCIPcreateConsBasicSOCNonlinear	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_Real *	coefs,
		SCIP_Real *	offsets,
		SCIP_Real	constant,
		SCIP_VAR *	rhsvar,
		SCIP_Real	rhscoeff,
		SCIP_Real	rhsoffset )

creates and captures a nonlinear constraint that is a second-order cone constraint with all its constraint flags set to their default values

\(\sqrt{\gamma + \sum_{i=1}^{n} (\alpha_i\, (x_i + \beta_i))^2} \leq \alpha_{n+1}\, (x_{n+1}+\beta_{n+1})\)

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nvars	number of variables on left hand side of constraint (n)
vars	array with variables on left hand side (x_i)
coefs	array with coefficients of left hand side variables (alpha_i), or NULL if all 1.0
offsets	array with offsets of variables (beta_i), or NULL if all 0.0
constant	constant on left hand side (gamma)
rhsvar	variable on right hand side of constraint (x_{n+1})
rhscoeff	coefficient of variable on right hand side (alpha_{n+1})
rhsoffset	offset of variable on right hand side (beta_{n+1})

Definition at line 12991 of file cons_nonlinear.c.

References assert(), i, NULL, nvars, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_Real, SCIPappendExprSumExpr(), SCIPcreateConsBasicNonlinear(), SCIPcreateExprPow(), SCIPcreateExprSum(), SCIPcreateExprVar(), SCIPerrorMessage, SCIPinfinity(), SCIPisFinite, SCIPisInfinity(), SCIPreleaseExpr(), SCIPvarGetName(), and vars.

SCIPcreateConsBasicSignpowerNonlinear()

SCIP_RETCODE SCIPcreateConsBasicSignpowerNonlinear	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_VAR *	x,
		SCIP_VAR *	z,
		SCIP_Real	exponent,
		SCIP_Real	xoffset,
		SCIP_Real	zcoef,
		SCIP_Real	lhs,
		SCIP_Real	rhs )

creates and captures a signpower nonlinear constraint with all its constraint flags set to their default values

\(\textrm{lhs} \leq \textrm{sign}(x+a) |x+a|^n + c z \leq \textrm{rhs}\)

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
x	nonlinear variable x in constraint
z	linear variable z in constraint
exponent	exponent n of |x+offset|^n term in constraint
xoffset	offset in |x+offset|^n term in constraint
zcoef	coefficient of z in constraint
lhs	left hand side of constraint
rhs	right hand side of constraint

Definition at line 13093 of file cons_nonlinear.c.

References assert(), NULL, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_Real, SCIPcreateConsBasicNonlinear(), SCIPcreateExprSignpower(), SCIPcreateExprSum(), SCIPcreateExprVar(), SCIPerrorMessage, SCIPisFinite, SCIPreleaseExpr(), and x.

SCIPgetCurBoundsTagNonlinear()

SCIP_Longint SCIPgetCurBoundsTagNonlinear

(

SCIP_CONSHDLR *

conshdlr

)

gets tag indicating current local variable bounds

Parameters

conshdlr

nonlinear constraint handler

Definition at line 13162 of file cons_nonlinear.c.

References assert(), NULL, SCIP_Longint, and SCIPconshdlrGetData().

Referenced by SCIP_DECL_NLHDLRINTEVAL().

SCIPgetLastBoundRelaxTagNonlinear()

SCIP_Longint SCIPgetLastBoundRelaxTagNonlinear

(

SCIP_CONSHDLR *

conshdlr

)

gets the curboundstag from the last time where variable bounds were relaxed

Parameters

conshdlr

nonlinear constraint handler

Definition at line 13175 of file cons_nonlinear.c.

References assert(), NULL, SCIP_Longint, and SCIPconshdlrGetData().

SCIPincrementCurBoundsTagNonlinear()

void SCIPincrementCurBoundsTagNonlinear	(	SCIP_CONSHDLR *	conshdlr,
		SCIP_Bool	boundrelax )

increments curboundstag and resets lastboundrelax in constraint handler data

Attention

This method is not intended for normal use. These tags are maintained by the event handler for variable bound change events. This method is used by some unittests.

Parameters

conshdlr	nonlinear constraint handler
boundrelax	indicates whether a bound was relaxed, i.e., lastboundrelax should be set too

Definition at line 13193 of file cons_nonlinear.c.

References assert(), NULL, SCIP_Bool, and SCIPconshdlrGetData().

Referenced by detectNlhdlrs(), and SCIPmarkExprPropagateNonlinear().

SCIPgetVarExprHashmapNonlinear()

SCIP_HASHMAP * SCIPgetVarExprHashmapNonlinear

(

SCIP_CONSHDLR *

conshdlr

)

returns the hashmap that is internally used to map variables to their corresponding variable expressions

Parameters

conshdlr

nonlinear constraint handler

Definition at line 13211 of file cons_nonlinear.c.

References assert(), NULL, and SCIPconshdlrGetData().

Referenced by getNLPVarsNonConvexity().

SCIPprocessRowprepNonlinear()

SCIP_RETCODE SCIPprocessRowprepNonlinear	(	SCIP *	scip,
		SCIP_NLHDLR *	nlhdlr,
		SCIP_CONS *	cons,
		SCIP_EXPR *	expr,
		SCIP_ROWPREP *	rowprep,
		SCIP_Bool	overestimate,
		SCIP_VAR *	auxvar,
		SCIP_Real	auxvalue,
		SCIP_Bool	allowweakcuts,
		SCIP_Bool	branchscoresuccess,
		SCIP_Bool	inenforcement,
		SCIP_SOL *	sol,
		SCIP_RESULT *	result )

processes a rowprep for cut addition and maybe report branchscores

Parameters

scip	SCIP data structure
nlhdlr	nonlinear handler which provided the estimator
cons	nonlinear constraint
expr	expression
rowprep	cut to be added
overestimate	whether the expression needs to be over- or underestimated
auxvar	auxiliary variable
auxvalue	current value of expression w.r.t. auxiliary variables as obtained from EVALAUX
allowweakcuts	whether we should only look for "strong" cuts, or anything that separates is fine
branchscoresuccess	whether the estimator generation generated branching scores
inenforcement	whether we are in enforcement, or only in separation
sol	solution to be separated (NULL for the LP solution)
result	pointer to store the result

Definition at line 13221 of file cons_nonlinear.c.

References addExprViolScoresAuxVars(), assert(), ENFOLOG, FALSE, getExprAbsAuxViolation(), i, NULL, REALABS, result, SCIP_Bool, SCIP_BRANCHED, SCIP_CALL, SCIP_CUTOFF, SCIP_INVALID, SCIP_OKAY, SCIP_Real, SCIP_SEPARATED, SCIPaddRow(), SCIPcleanupRowprep(), SCIPcleanupRowprep2(), SCIPconsGetHdlr(), SCIPconshdlrGetData(), SCIPfeastol(), SCIPgetCutEfficacy(), SCIPgetExprRelAuxViolationNonlinear(), SCIPgetLPFeastol(), SCIPgetRowprepRowCons(), SCIPgetRowprepViolation(), SCIPgetSepaMinEfficacy(), SCIPgetSolVal(), SCIPinfoMessage(), SCIPisCutApplicable(), SCIPisCutEfficacious(), SCIPisEQ(), SCIPmarkRowNotRemovableLocal(), SCIPnlhdlrGetName(), SCIPnlhdlrIncrementNCutoffs, SCIPnlhdlrIncrementNSeparated, SCIPprintRow(), SCIPprintRowprep(), SCIPreleaseRow(), SCIProwprepGetCoefs(), SCIProwprepGetModifiedVars(), SCIProwprepGetName(), SCIProwprepGetNModifiedVars(), SCIProwprepGetNVars(), SCIProwprepGetVars(), SCIProwprepRecordModifications(), sol, and TRUE.

Referenced by enforceExprNlhdlr(), and SCIP_DECL_NLHDLRENFO().

SCIPassumeConvexNonlinear()

SCIP_Bool SCIPassumeConvexNonlinear

(

SCIP_CONSHDLR *

conshdlr

)

returns whether all nonlinear constraints are assumed to be convex

Definition at line 13492 of file cons_nonlinear.c.

References assert(), NULL, SCIP_Bool, and SCIPconshdlrGetData().

Referenced by SCIP_DECL_NLHDLRDETECT().

SCIPcollectBilinTermsNonlinear()

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

collects all bilinear terms for a given set of constraints

Attention

This method should only be used for unit tests that depend on SCIPgetBilinTermsNonlinear(), SCIPgetBilinTermNonlinear() or SCIPgetBilinTermIdxNonlinear().

Parameters

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

Definition at line 13511 of file cons_nonlinear.c.

References assert(), bilinearTermsInsertAll(), NULL, SCIP_CALL, and SCIP_OKAY.

SCIPgetNBilinTermsNonlinear()

int SCIPgetNBilinTermsNonlinear

(

SCIP_CONSHDLR *

conshdlr

)

returns the total number of bilinear terms that are contained in all nonlinear constraints

Note

This method should only be used after auxiliary variables have been created, i.e., after CONSINITLP.

Parameters

conshdlr

nonlinear constraint handler

Definition at line 13530 of file cons_nonlinear.c.

References assert(), NULL, and SCIPconshdlrGetData().

Referenced by createSepaData(), getBestEstimators(), markRowsXj(), SCIP_DECL_SEPAEXECLP(), and separateMcCormickImplicit().

SCIPgetBilinTermsNonlinear()

SCIP_CONSNONLINEAR_BILINTERM * SCIPgetBilinTermsNonlinear

(

SCIP_CONSHDLR *

conshdlr

)

returns all bilinear terms that are contained in all nonlinear constraints

Note

This method should only be used after auxiliary variables have been created, i.e., after CONSINITLP.

The value of the auxiliary variable of a bilinear term might be NULL, which indicates that the term does not have an auxiliary variable.

Parameters

conshdlr

nonlinear constraint handler

Definition at line 13549 of file cons_nonlinear.c.

References assert(), NULL, and SCIPconshdlrGetData().

Referenced by addRltTerm(), createSepaData(), getBestEstimators(), isAcceptableRow(), markRowsXj(), and separateMcCormickImplicit().

SCIPgetBilinTermIdxNonlinear()

int SCIPgetBilinTermIdxNonlinear	(	SCIP_CONSHDLR *	conshdlr,
		SCIP_VAR *	x,
		SCIP_VAR *	y )

returns the index of the bilinear term representing the product of the two given variables

Note

The method should only be used after auxiliary variables have been created, i.e., after CONSINITLP.

Returns

The method returns -1 if the variables do not appear bilinearly.

Parameters

conshdlr	nonlinear constraint handler
x	first variable
y	second variable

Definition at line 13568 of file cons_nonlinear.c.

References assert(), NULL, SCIPconshdlrGetData(), SCIPhashtableRetrieve(), SCIPswapPointers(), SCIPvarCompare(), SCIP_ConsNonlinear_BilinTerm::x, x, SCIP_ConsNonlinear_BilinTerm::y, and y.

Referenced by addRltTerm(), bilinearTermsInsertEntry(), isAcceptableRow(), markRowsXj(), and SCIPgetBilinTermNonlinear().

SCIPgetBilinTermNonlinear()

SCIP_CONSNONLINEAR_BILINTERM * SCIPgetBilinTermNonlinear	(	SCIP_CONSHDLR *	conshdlr,
		SCIP_VAR *	x,
		SCIP_VAR *	y )

returns the bilinear term that represents the product of two given variables

Note

The method should only be used after auxiliary variables have been created, i.e., after CONSINITLP.

Returns

The method returns NULL if the variables do not appear bilinearly.

Parameters

conshdlr	nonlinear constraint handler
x	first variable
y	second variable

Definition at line 13613 of file cons_nonlinear.c.

References assert(), NULL, SCIPconshdlrGetData(), SCIPgetBilinTermIdxNonlinear(), x, and y.

SCIPevalBilinAuxExprNonlinear()

SCIP_Real SCIPevalBilinAuxExprNonlinear	(	SCIP *	scip,
		SCIP_VAR *	x,
		SCIP_VAR *	y,
		SCIP_CONSNONLINEAR_AUXEXPR *	auxexpr,
		SCIP_SOL *	sol )

evaluates an auxiliary expression for a bilinear term

Parameters

scip	SCIP data structure
x	first variable of the bilinear term
y	second variable of the bilinear term
auxexpr	auxiliary expression
sol	solution at which to evaluate (can be NULL)

Definition at line 13641 of file cons_nonlinear.c.

References assert(), SCIP_ConsNonlinear_Auxexpr::auxvar, SCIP_ConsNonlinear_Auxexpr::coefs, SCIP_ConsNonlinear_Auxexpr::cst, NULL, SCIP_Real, SCIPgetSolVal(), sol, x, and y.

Referenced by getBestEstimators(), markRowsXj(), and separateMcCormickImplicit().

SCIPinsertBilinearTermExistingNonlinear()

SCIP_RETCODE SCIPinsertBilinearTermExistingNonlinear	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_VAR *	x,
		SCIP_VAR *	y,
		SCIP_VAR *	auxvar,
		int	nlockspos,
		int	nlocksneg )

stores the variables of a bilinear term in the data of the constraint handler

Parameters

scip	SCIP data structure
conshdlr	constraint handler
x	first variable
y	second variable
auxvar	auxiliary variable (might be NULL)
nlockspos	number of positive expression locks
nlocksneg	number of negative expression locks

Definition at line 13660 of file cons_nonlinear.c.

References assert(), SCIP_ConsNonlinear_BilinTerm::aux, bilinearTermsInsertEntry(), SCIP_ConsNonlinear_BilinTerm::nauxexprs, NULL, SCIP_CALL, SCIP_OKAY, SCIPcaptureVar(), SCIPconshdlrGetData(), TRUE, SCIP_ConsNonlinear_BilinTerm::var, x, and y.

Referenced by bilinearTermsInsertAll().

SCIPinsertBilinearTermImplicitNonlinear()

SCIP_RETCODE SCIPinsertBilinearTermImplicitNonlinear	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_VAR *	x,
		SCIP_VAR *	y,
		SCIP_VAR *	auxvar,
		SCIP_Real	coefx,
		SCIP_Real	coefy,
		SCIP_Real	coefaux,
		SCIP_Real	cst,
		SCIP_Bool	overestimate )

stores the variables of a bilinear term in the data of the constraint handler

Parameters

scip	SCIP data structure
conshdlr	constraint handler
x	first variable
y	second variable
auxvar	auxiliary variable (might be NULL)
coefx	coefficient of x in the auxiliary expression
coefy	coefficient of y in the auxiliary expression
coefaux	coefficient of auxvar in the auxiliary expression
cst	constant of the auxiliary expression
overestimate	whether the auxiliary expression overestimates the bilinear product

Definition at line 13697 of file cons_nonlinear.c.

References assert(), SCIP_ConsNonlinear_BilinTerm::aux, SCIP_ConsNonlinear_Auxexpr::auxvar, bilinearTermsInsertEntry(), bilinTermAddAuxExpr(), SCIP_ConsNonlinear_Auxexpr::coefs, SCIP_ConsNonlinear_Auxexpr::cst, SCIP_ConsNonlinear_BilinTerm::existing, SCIP_ConsNonlinear_BilinTerm::exprs, FALSE, SCIP_ConsNonlinear_BilinTerm::nauxexprs, SCIP_ConsNonlinear_BilinTerm::nlocksneg, SCIP_ConsNonlinear_BilinTerm::nlockspos, NULL, SCIP_ConsNonlinear_Auxexpr::overestimate, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPallocBlockMemory, SCIPcaptureVar(), SCIPconshdlrGetData(), SCIPfreeBlockMemory, SCIPvarCompare(), SCIP_ConsNonlinear_Auxexpr::underestimate, SCIP_ConsNonlinear_BilinTerm::var, SCIP_ConsNonlinear_BilinTerm::x, x, SCIP_ConsNonlinear_BilinTerm::y, and y.

Referenced by extractProducts().

SCIPcomputeFacetVertexPolyhedralNonlinear()

SCIP_RETCODE SCIPcomputeFacetVertexPolyhedralNonlinear	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_Bool	overestimate,
		SCIP_DECL_VERTEXPOLYFUN((*function))	,
		void *	fundata,
		SCIP_Real *	xstar,
		SCIP_Real *	box,
		int	nallvars,
		SCIP_Real	targetvalue,
		SCIP_Bool *	success,
		SCIP_Real *	facetcoefs,
		SCIP_Real *	facetconstant )

computes a facet of the convex or concave envelope of a vertex polyhedral function

If \( f(x) \) is vertex-polyhedral, then \( g \) is a convex underestimator if and only if \( g(v^i) \leq f(v^i), \forall i \), where \( \{ v^i \}_{i = 1}^{2^n} \subseteq \mathbb R^n \) are the vertices of the domain of \( x \), \( [\ell,u] \). Hence, we can compute a linear underestimator by solving the following LP (we don't necessarily get a facet of the convex envelope, see below):

\begin{align*} \max \, & \alpha^T x^* + \beta \\ s.t. \; & \alpha^T v^i + \beta \le f(v^i), \, \forall i = 1, \ldots, 2^n \end{align*}

In principle, one would need to update the LP whenever the domain changes. However, \( [\ell,u] = T([0, 1]^n) \), where \( T \) is an affine linear invertible transformation given by \( T(y)_i = (u_i - \ell_i) y_i + \ell_i \). Working with the change of variables \( x = T(y) \) allows us to keep the constraints of the LP, even if the domain changes. Indeed, after the change of variables, the problem is: find an affine underestimator \( g \) such that \(g(T(y)) \le f(T(y)) \), for all \( y \in [0, 1]^n \). Now \( f(T(y)) \) is componentwise affine, but still satisfies that \( g \) is a valid underestimator if and only if \( g(T(u)) \leq f(T(u)), \forall u \in \{0, 1\}^n \). So we now look for \( \bar g(y) := g(T(y)) = g(((u_i - \ell_i) y_i + \ell_i)_i) = \bar \alpha^T y + \bar \beta \), where \( \bar \alpha_i = (u_i - \ell_i) \alpha_i \) and \( \bar \beta = \sum_i \alpha_i \ell_i + \beta \). So we find \( \bar g \) by solving the LP:

\begin{align*} \max \, & \bar \alpha^T T^{-1}(x^*) + \bar \beta \\ s.t. \; & \bar \alpha^T u + \bar \beta \le f(T(u)), \, \forall u \in \{0, 1\}^n \end{align*}

and recover \( g \) by calculating \( \bar \alpha_i = (u_i - \ell_i) \alpha_i, \bar \beta = \sum_i \alpha_i \ell_i + \beta \). Notice that \( f(T(u^i)) = f(v^i) \) so the right hand side doesn't change after the change of variables.

Furthermore, the LP has more constraints than variables, so we solve its dual:

\begin{align*} \min \, & \sum_i \lambda_i f(v^i) \\ s.t. \; & \sum_i \lambda_i u^i = T^{-1}(x^*) \\ & \sum_i \lambda_i = 1 \\ & \forall i, \, \lambda_i \geq 0 \end{align*}

In case we look for an overestimate, we do exactly the same, but have to maximize in the dual LP instead of minimize.

Technical and implementation details

1. \( U \) has exponentially many variables, so we only apply this separator for \(n\) ≤ SCIP_MAXVERTEXPOLYDIM.
2. If the bounds are not finite, there is no underestimator. Also, \( T^{-1}(x^*) \) must be in the domain, otherwise the dual is infeasible.
3. After a facet is computed, we check whether it is a valid facet (i.e. we check \( \alpha^T v + \beta \le f(v) \) for every vertex \( v \)). If we find a violation of at most ADJUSTFACETFACTOR * SCIPgetLPFeastol(), then we weaken \( \beta \) by this amount, otherwise, we discard the cut.
4. If a variable is fixed within tolerances, we replace it with its value and compute the facet of the remaining expression. Note that since we are checking the cut for validity, this will never produce wrong result.
5. If \( x^* \) is in the boundary of the domain, then the LP has infinitely many solutions, some of which might have very bad numerical properties. For this reason, we perturb \( x^* \) to be in the interior of the region. Furthermore, for some interior points, there might also be infinitely many solutions (e.g. for \( x y \) in \([0,1]^2 \) any point \( (x^*, y^*) \) such that \( y^* = 1 - x^* \) has infinitely many solutions). For this reason, we perturb any given \( x^* \). The idea is to try to get a facet of the convex/concave envelope. This only happens when the solution has \( n + 1 \) non zero \( \lambda \)'s (i.e. the primal has a unique solution).
6. We need to compute \( f(v^i) \) for every vertex of \( [\ell,u] \). A vertex is encoded by a number between 0 and \( 2^n - 1 \), via its binary representation (0 bit is lower bound, 1 bit is upper bound), so we can compute all these values by iterating between 0 and \( 2^n - 1 \).
7. To check that the computed cut is valid we do the following: we use a gray code to loop over the vertices of the box domain w.r.t. unfixed variables in order to evaluate the underestimator. To ensure the validity of the underestimator, we check whether \( \alpha v^i + \beta \le f(v^i) \) for every vertex \( v^i \) and adjust \( \beta \) if the maximal violation is small.

Parameters

scip	SCIP data structure
conshdlr	nonlinear constraint handler
overestimate	whether to compute facet of concave (TRUE) or convex (FALSE) envelope
fundata	data for function evaluation (can be NULL)
xstar	point to be separated
box	box where to compute facet: should be lb_1, ub_1, lb_2, ub_2...
nallvars	half of the length of box
targetvalue	target value: no need to compute facet if value in xstar would be worse than this value
success	buffer to store whether a facet could be computed successfully
facetcoefs	buffer to store coefficients of facet defining inequality; must be an array of length at least nallvars
facetconstant	buffer to store constant part of facet defining inequality

Definition at line 13795 of file cons_nonlinear.c.

References assert(), BMSclearMemoryArray, computeVertexPolyhedralFacetBivariate(), computeVertexPolyhedralFacetLP(), computeVertexPolyhedralFacetUnivariate(), computeVertexPolyhedralMaxFacetError(), FALSE, i, NULL, nvars, POWEROFTWO, REALABS, SCIP_Bool, SCIP_CALL, SCIP_INVALID, SCIP_MAXVERTEXPOLYDIM, SCIP_OKAY, SCIP_Real, SCIP_STAGE_SOLVING, SCIPallocBufferArray, SCIPconshdlrGetData(), SCIPdebugMsg, SCIPdebugMsgPrint, SCIPfeastol(), SCIPfreeBufferArray, SCIPgetLPFeastol(), SCIPgetStage(), SCIPisInfinity(), SCIPisRelEQ(), SCIPlapackIsAvailable(), and SCIPwarningMessage().

Referenced by estimateVertexPolyhedral(), estimateVertexPolyhedralProduct(), and underEstimatePower().

SCIPgetExprNonlinear()

SCIP_EXPR * SCIPgetExprNonlinear

(

SCIP_CONS *

cons

)

returns the expression of the given nonlinear constraint

Parameters

cons	constraint data

Definition at line 13986 of file cons_nonlinear.c.

References assert(), CONSHDLR_NAME, NULL, SCIPconsGetData(), SCIPconsGetHdlr(), and SCIPconshdlrGetName().

Referenced by addSymmetryInformation(), checkSubproblemConvexity(), constructHypergraph(), detectMinors(), detectMinors(), SCIPNLFeeder::FeedConExpression(), isPackingCons(), SCIP_DECL_NONLINCONSUPGD(), SCIP_DECL_NONLINCONSUPGD(), SCIP_DECL_PRESOLEXEC(), SCIP_DECL_TABLECOLLECT(), SCIP_DECL_TABLEOUTPUT(), SCIPisSOCNonlinear(), SCIPwriteGms(), SCIPwriteLp(), SCIPwriteMps(), and SCIPwritePip().

SCIPgetLhsNonlinear()

SCIP_Real SCIPgetLhsNonlinear

(

SCIP_CONS *

cons

)

gets the left hand side of a nonlinear constraint

Parameters

cons	constraint data

Definition at line 14002 of file cons_nonlinear.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_Real, SCIPconsGetData(), SCIPconsGetHdlr(), and SCIPconshdlrGetName().

Referenced by addSlackVars(), addSymmetryInformation(), checkConsnames(), checkConsQuadraticProblem(), checkSubproblemConvexity(), intercutsComputeCommonQuantities(), isQuadConsViolated(), SCIP_DECL_NLHDLRDETECT(), SCIP_DECL_NLHDLRENFO(), SCIP_DECL_NONLINCONSUPGD(), SCIP_DECL_NONLINCONSUPGD(), SCIPisSOCNonlinear(), SCIPwriteGms(), SCIPwriteLp(), SCIPwriteMps(), and SCIPwritePip().

SCIPgetRhsNonlinear()

SCIP_Real SCIPgetRhsNonlinear

(

SCIP_CONS *

cons

)

gets the right hand side of a nonlinear constraint

Parameters

cons	constraint data

Definition at line 14018 of file cons_nonlinear.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_Real, SCIPconsGetData(), SCIPconsGetHdlr(), and SCIPconshdlrGetName().

Referenced by addSlackVars(), addSymmetryInformation(), checkConsnames(), checkConsQuadraticProblem(), checkSubproblemConvexity(), intercutsComputeCommonQuantities(), isQuadConsViolated(), SCIP_DECL_NLHDLRDETECT(), SCIP_DECL_NLHDLRENFO(), SCIP_DECL_NONLINCONSUPGD(), SCIP_DECL_NONLINCONSUPGD(), SCIPisSOCNonlinear(), SCIPwriteGms(), SCIPwriteLp(), SCIPwriteMps(), and SCIPwritePip().

SCIPgetNlRowNonlinear()

SCIP_RETCODE SCIPgetNlRowNonlinear	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_NLROW **	nlrow )

gets the nonlinear constraint as a nonlinear row representation.

Parameters

scip	SCIP data structure
cons	constraint
nlrow	pointer to store nonlinear row

Definition at line 14034 of file cons_nonlinear.c.

References assert(), CONSHDLR_NAME, createNlRow(), NULL, SCIP_CALL, SCIP_OKAY, SCIPconsGetData(), SCIPconsGetHdlr(), and SCIPconshdlrGetName().

Referenced by createCoveringProblem().

SCIPgetCurvatureNonlinear()

SCIP_EXPRCURV SCIPgetCurvatureNonlinear

(

SCIP_CONS *

cons

)

returns the curvature of the expression of a given nonlinear constraint

Note

The curvature information is computed during CONSINITSOL.

Parameters

cons	constraint data

Definition at line 14063 of file cons_nonlinear.c.

References assert(), CONSHDLR_NAME, NULL, SCIPconsGetData(), SCIPconsGetHdlr(), and SCIPconshdlrGetName().

Referenced by checkSubproblemConvexity().

SCIPcheckQuadraticNonlinear()

SCIP_RETCODE SCIPcheckQuadraticNonlinear	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool *	isquadratic )

checks whether expression of constraint can be represented as quadratic form

Only sets *isquadratic to TRUE if the whole expression is quadratic (in the non-extended formulation) and non-linear. That is, the expression in each SCIP_QUADEXPR_QUADTERM will be a variable expressions and SCIPgetVarExprVar() can be used to retrieve the variable.

Parameters

scip	SCIP data structure
cons	constraint data
isquadratic	buffer to store whether constraint is quadratic

Definition at line 14084 of file cons_nonlinear.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIPcheckExprQuadratic(), SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPexprAreQuadraticExprsVariables().

Referenced by SCIP_DECL_NONLINCONSUPGD(), SCIP_DECL_PRESOLEXEC(), and SCIPwriteLp().

SCIPchgLhsNonlinear()

SCIP_RETCODE SCIPchgLhsNonlinear	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Real	lhs )

changes left-hand-side of a nonlinear constraint

Attention

This method can only be called in the problem stage.

Parameters

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

Definition at line 14115 of file cons_nonlinear.c.

References assert(), CONSHDLR_NAME, FALSE, NULL, SCIP_INVALIDCALL, SCIP_OKAY, SCIP_Real, SCIP_STAGE_PROBLEM, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPconsIsOriginal(), SCIPerrorMessage, and SCIPgetStage().

Referenced by AMPLProblemHandler::OnConBounds().

SCIPchgRhsNonlinear()

SCIP_RETCODE SCIPchgRhsNonlinear	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Real	rhs )

changes right-hand-side of a nonlinear constraint

Attention

This method can only be called in the problem stage.

Parameters

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

Definition at line 14154 of file cons_nonlinear.c.

References assert(), CONSHDLR_NAME, FALSE, NULL, SCIP_INVALIDCALL, SCIP_OKAY, SCIP_Real, SCIP_STAGE_PROBLEM, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPconsIsOriginal(), SCIPerrorMessage, and SCIPgetStage().

Referenced by AMPLProblemHandler::OnConBounds().

SCIPchgExprNonlinear()

SCIP_RETCODE SCIPchgExprNonlinear	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_EXPR *	expr )

changes expression of a nonlinear constraint

Attention

This method can only be called in the problem stage.

Parameters

scip	SCIP data structure
cons	constraint data
expr	new expression

Definition at line 14193 of file cons_nonlinear.c.

References assert(), CONSHDLR_NAME, FALSE, NULL, SCIP_CALL, SCIP_EXPRCURV_UNKNOWN, SCIP_INVALIDCALL, SCIP_OKAY, SCIP_STAGE_PROBLEM, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPconsIsOriginal(), SCIPduplicateExpr(), SCIPerrorMessage, SCIPgetStage(), and SCIPreleaseExpr().

Referenced by AMPLProblemHandler::OnAlgebraicCon().

SCIPaddLinearVarNonlinear()

SCIP_RETCODE SCIPaddLinearVarNonlinear	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var,
		SCIP_Real	coef )

adds coef * var to nonlinear constraint

Attention

This method can only be called in the problem stage.

Parameters

scip	SCIP data structure
cons	constraint data
var	variable
coef	coefficient

Definition at line 14247 of file cons_nonlinear.c.

References assert(), CONSHDLR_NAME, createExprVar(), FALSE, NULL, SCIP_CALL, SCIP_INVALIDCALL, SCIP_OKAY, SCIP_Real, SCIP_STAGE_PROBLEM, SCIPappendExprSumExpr(), SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPconsIsOriginal(), SCIPcreateExprSum(), SCIPerrorMessage, SCIPexprGetNUses(), SCIPgetStage(), SCIPisExprSum(), SCIPreleaseExpr(), and var.

Referenced by addSlackVars(), and AMPLProblemHandler::EndInput().

SCIPaddExprNonlinear()

SCIP_RETCODE SCIPaddExprNonlinear	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_EXPR *	expr,
		SCIP_Real	coef )

adds coef * expr to nonlinear constraint

Attention

This method can only be called in the problem stage.

Parameters

scip	SCIP data structure
cons	nonlinear constraint
expr	expression
coef	coefficient

Definition at line 14320 of file cons_nonlinear.c.

References assert(), CONSHDLR_NAME, FALSE, freeVarExprs(), NULL, SCIP_CALL, SCIP_INVALIDCALL, SCIP_OKAY, SCIP_Real, SCIP_STAGE_PROBLEM, SCIPappendExprSumExpr(), SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPconsIsOriginal(), SCIPcreateExprSum(), SCIPduplicateExpr(), SCIPerrorMessage, SCIPexprGetNUses(), SCIPfreeExprQuadratic(), SCIPgetStage(), SCIPisExprSum(), and SCIPreleaseExpr().

SCIPgetAbsViolationNonlinear()

SCIP_RETCODE SCIPgetAbsViolationNonlinear	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SOL *	sol,
		SCIP_Real *	viol )

gets absolute violation of nonlinear constraint

This function evaluates the constraints in the given solution.

If this value is at most SCIPfeastol(), the constraint would be considered feasible.

Parameters

scip	SCIP data structure
cons	constraint
sol	solution to check
viol	buffer to store computed violation

Definition at line 14423 of file cons_nonlinear.c.

References assert(), computeViolation(), getConsAbsViolation(), NULL, SCIP_CALL, SCIP_OKAY, SCIP_Real, and sol.

SCIPgetRelViolationNonlinear()

SCIP_RETCODE SCIPgetRelViolationNonlinear	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SOL *	sol,
		SCIP_Real *	viol )

gets scaled violation of nonlinear constraint

This function evaluates the constraints in the given solution.

The scaling that is applied to the absolute violation of the constraint depends on the setting of parameter constraints/nonlinear/violscale.

Parameters

scip	SCIP data structure
cons	constraint
sol	solution to check
viol	buffer to store computed violation

Definition at line 14446 of file cons_nonlinear.c.

References assert(), computeViolation(), getConsRelViolation(), NULL, SCIP_CALL, SCIP_OKAY, SCIP_Real, and sol.

SCIPgetLinvarMayDecreaseNonlinear()

void SCIPgetLinvarMayDecreaseNonlinear	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR **	var,
		SCIP_Real *	coef )

returns a variable that appears linearly that may be decreased without making any other constraint infeasible

Parameters

scip	SCIP data structure
cons	nonlinear constraint
var	pointer to store the variable
coef	pointer to store the coefficient

Definition at line 14463 of file cons_nonlinear.c.

References assert(), findUnlockedLinearVar(), NULL, SCIP_Real, SCIPconsGetData(), and var.

SCIPgetLinvarMayIncreaseNonlinear()

void SCIPgetLinvarMayIncreaseNonlinear	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR **	var,
		SCIP_Real *	coef )

returns a variable that appears linearly that may be increased without making any other constraint infeasible

Parameters

scip	SCIP data structure
cons	nonlinear constraint
var	pointer to store the variable
coef	pointer to store the coefficient

Definition at line 14487 of file cons_nonlinear.c.

References assert(), findUnlockedLinearVar(), NULL, SCIP_Real, SCIPconsGetData(), and var.

Referenced by checkConsQuadraticProblem().

SCIPgetExprNLocksPosNonlinear()

int SCIPgetExprNLocksPosNonlinear

(

SCIP_EXPR *

expr

)

returns the number of positive rounding locks of an expression

Parameters

expr	expression

Definition at line 14516 of file cons_nonlinear.c.

References assert(), NULL, and SCIPexprGetOwnerData().

Referenced by bilinboundGetLocksPos(), bilinearTermsInsertAll(), detectSocNorm(), and detectSocQuadraticComplex().

SCIPgetExprNLocksNegNonlinear()

int SCIPgetExprNLocksNegNonlinear

(

SCIP_EXPR *

expr

)

returns the number of negative rounding locks of an expression

Parameters

expr	expression

Definition at line 14527 of file cons_nonlinear.c.

References assert(), NULL, and SCIPexprGetOwnerData().

Referenced by bilinboundGetLocksNeg(), bilinearTermsInsertAll(), and detectSocQuadraticComplex().

SCIPgetExprAuxVarNonlinear()

SCIP_VAR * SCIPgetExprAuxVarNonlinear

(

SCIP_EXPR *

expr

)

returns the variable used for linearizing a given expression (return value might be NULL)

Note

for variable expression it returns the corresponding variable

Parameters

expr	expression

Definition at line 14541 of file cons_nonlinear.c.

References assert(), NULL, SCIPexprGetOwnerData(), and SCIPgetVarExprVar().

Referenced by addExprsViolScore(), addExprViolScoresAuxVars(), bilinboundGetX(), bilinboundGetY(), bilinearTermsInsertAll(), collectBranchingCandidates(), collectLeafs(), computeOffValues(), constructHypergraph(), constructLPPos2ConsPosMap(), countBasicVars(), createDisaggrRow(), detectMinors(), detectMinors(), enforceExprNlhdlr(), estimateBivariateQuotient(), estimateUnivariateQuotient(), evalExprInAux(), findVertexAndGetRays(), generateCutSolDisagg(), generateCutSolSOC(), generateIntercut(), initBounds(), intercutsComputeCommonQuantities(), isQuadConsViolated(), registerBranchingCandidates(), SCIP_DECL_NLHDLRENFO(), SCIP_DECL_NLHDLRENFO(), SCIP_DECL_NLHDLRESTIMATE(), SCIP_DECL_NLHDLRESTIMATE(), SCIP_DECL_NLHDLRESTIMATE(), SCIP_DECL_NLHDLRESTIMATE(), SCIP_DECL_NLHDLREVALAUX(), SCIP_DECL_NLHDLREVALAUX(), SCIP_DECL_NLHDLREVALAUX(), SCIP_DECL_NLHDLREVALAUX(), SCIP_DECL_NLHDLREVALAUX(), SCIP_DECL_NLHDLREVALAUX(), SCIP_DECL_NLHDLRINITSEPA(), SCIP_DECL_NLHDLRINITSEPA(), SCIP_DECL_NLHDLRINITSEPA(), SCIP_DECL_NLHDLRINITSEPA(), SCIP_DECL_NLHDLRSOLLINEARIZE(), SCIP_DECL_NLHDLRSOLLINEARIZE(), SCIP_DECL_NLHDLRSOLLINEARIZE(), SCIPaddIneqBilinear(), SCIPevalExprQuadraticAuxNonlinear(), scoreBranchingCandidates(), storeCaptureVars(), storeDenseTableauRowsByColumns(), tightenAuxVarBounds(), and updateVarVals().

SCIPgetExprNEnfosNonlinear()

int SCIPgetExprNEnfosNonlinear

(

SCIP_EXPR *

expr

)

returns the number of enforcements for an expression

Parameters

expr	expression

Definition at line 14556 of file cons_nonlinear.c.

References assert(), NULL, and SCIPexprGetOwnerData().

Referenced by SCIP_DECL_NLHDLRDETECT(), SCIP_DECL_NLHDLRENFO(), and SCIP_DECL_NLHDLREVALAUX().

SCIPgetExprEnfoDataNonlinear()

void SCIPgetExprEnfoDataNonlinear	(	SCIP_EXPR *	expr,
		int	idx,
		SCIP_NLHDLR **	nlhdlr,
		SCIP_NLHDLREXPRDATA **	nlhdlrexprdata,
		SCIP_NLHDLR_METHOD *	nlhdlrparticipation,
		SCIP_Bool *	sepabelowusesactivity,
		SCIP_Bool *	sepaaboveusesactivity,
		SCIP_Real *	auxvalue )

returns the data for one of the enforcements of an expression

Parameters

expr	expression
idx	position of enforcement in enfos array
nlhdlr	buffer to store nlhldr
nlhdlrexprdata	buffer to store nlhdlr data for expression, or NULL
nlhdlrparticipation	buffer to store methods where nonlinear handler participates, or NULL
sepabelowusesactivity	buffer to store whether sepabelow uses activity of some expression, or NULL
sepaaboveusesactivity	buffer to store whether sepaabove uses activity of some expression, or NULL
auxvalue	buffer to store current auxvalue, or NULL

Definition at line 14567 of file cons_nonlinear.c.

References assert(), NULL, SCIP_Bool, SCIP_Real, and SCIPexprGetOwnerData().

Referenced by SCIP_DECL_NLHDLRDETECT(), SCIP_DECL_NLHDLRENFO(), and SCIP_DECL_NLHDLREVALAUX().

SCIPsetExprEnfoAuxValueNonlinear()

void SCIPsetExprEnfoAuxValueNonlinear	(	SCIP_EXPR *	expr,
		int	idx,
		SCIP_Real	auxvalue )

sets the auxiliary value of expression for one of the enforcements of an expression

Parameters

expr	expression
idx	position of enforcement in enfos array
auxvalue	the new value of auxval

Definition at line 14608 of file cons_nonlinear.c.

References assert(), NULL, SCIP_Real, and SCIPexprGetOwnerData().

Referenced by SCIP_DECL_NLHDLREVALAUX().

SCIPgetExprNPropUsesActivityNonlinear()

unsigned int SCIPgetExprNPropUsesActivityNonlinear

(

SCIP_EXPR *

expr

)

number of nonlinear handlers whose activity computation and propagation methods depend on the activity of the expression

Note

This method can only be used after the detection methods of the nonlinear handlers have been called.

Parameters

expr	expression

Definition at line 14632 of file cons_nonlinear.c.

References assert(), NULL, and SCIPexprGetOwnerData().

SCIPgetExprNSepaUsesActivityNonlinear()

unsigned int SCIPgetExprNSepaUsesActivityNonlinear

(

SCIP_EXPR *

expr

)

number of nonlinear handlers whose separation methods (estimate or enforcement) depend on the activity of the expression

Note

This method can only be used after the detection methods of the nonlinear handlers have been called.

Parameters

expr	expression

Definition at line 14646 of file cons_nonlinear.c.

References assert(), NULL, and SCIPexprGetOwnerData().

Referenced by getNLPVarsNonConvexity().

SCIPgetExprNAuxvarUsesNonlinear()

unsigned int SCIPgetExprNAuxvarUsesNonlinear

(

SCIP_EXPR *

expr

)

number of nonlinear handlers whose separation methods (estimate or enforcement) use auxiliary variable of the expression

Note

This method can only be used after the detection methods of the nonlinear handlers have been called.

Parameters

expr	expression

Definition at line 14660 of file cons_nonlinear.c.

References assert(), NULL, and SCIPexprGetOwnerData().

Referenced by detectExpr(), SCIP_DECL_NLHDLRDETECT(), SCIP_DECL_NLHDLRDETECT(), SCIP_DECL_NLHDLRDETECT(), and SCIP_DECL_NLHDLRDETECT().

SCIPregisterExprUsageNonlinear()

SCIP_RETCODE SCIPregisterExprUsageNonlinear	(	SCIP *	scip,
		SCIP_EXPR *	expr,
		SCIP_Bool	useauxvar,
		SCIP_Bool	useactivityforprop,
		SCIP_Bool	useactivityforsepabelow,
		SCIP_Bool	useactivityforsepaabove )

method to be called by a nlhdlr during NLHDLRDETECT to notify an expression that it will be used

• if useauxvar is enabled, then ensures that an auxiliary variable will be created in INITLP
• if useactivityforprop or useactivityforsepa{below,above} is enabled, then ensured that activity will be updated for expr
• if useactivityforprop is enabled, then increments the count returned by SCIPgetExprNPropUsesActivityNonlinear()
• if useactivityforsepa{below,above} is enabled, then increments the count returned by SCIPgetExprNSepaUsesActivityNonlinear() and also increments this count for all variables in the expression.

The distinction into useactivityforprop and useactivityforsepa{below,above} is to recognize variables which domain influences under/overestimators. Domain propagation routines (like OBBT) may invest more work for these variables. The distinction into useactivityforsepabelow and useactivityforsepaabove is to recognize whether a nlhdlr that called this method will use activity of expr in enfomethod SCIP_NLHDLR_METHOD_SEPABELOW or SCIP_NLHDLR_METHOD_SEPAABOVE.

Parameters

scip	SCIP data structure
expr	expression
useauxvar	whether an auxiliary variable will be used for estimate or cut generation
useactivityforprop	whether activity of expr will be used by domain propagation or activity calculation (inteval)
useactivityforsepabelow	whether activity of expr will be used by underestimation
useactivityforsepaabove	whether activity of expr will be used by overestimation

Definition at line 14683 of file cons_nonlinear.c.

References assert(), FALSE, freeEnfoData(), NULL, SCIP_Bool, SCIP_CALL, SCIP_EXPRITER_DFS, SCIP_OKAY, SCIPconshdlrGetData(), SCIPcreateExpriter(), SCIPevalExprActivity(), SCIPexprGetNChildren(), SCIPexprGetOwnerData(), SCIPexpriterGetNext(), SCIPexpriterInit(), SCIPexpriterIsEnd(), SCIPfreeExpriter(), SCIPisExprVar(), and TRUE.

Referenced by createNlhdlrExprData(), detectExpr(), detectNlhdlrs(), detectSocNorm(), detectSocQuadraticComplex(), detectSocQuadraticSimple(), SCIP_DECL_NLHDLRDETECT(), SCIP_DECL_NLHDLRDETECT(), SCIP_DECL_NLHDLRDETECT(), and SCIP_DECL_NLHDLRDETECT().

SCIPgetExprActivityNonlinear()

SCIP_RETCODE SCIPgetExprActivityNonlinear	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SOL *	sol,
		SCIP_Real *	activity )

computes value of constraint expression in a given solution

Stores value of constraint expression in sol in activity. In case of a domain error (function cannot be evaluated in sol), activity is set to SCIP_INVALID.

Parameters

scip	SCIP data structure
cons	constraint
sol	solution
activity	buffer to store computed activity

Definition at line 14396 of file cons_nonlinear.c.

References assert(), NULL, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPconsGetData(), SCIPevalExpr(), SCIPexprGetEvalValue(), and sol.

SCIPgetExprAbsOrigViolationNonlinear()

SCIP_RETCODE SCIPgetExprAbsOrigViolationNonlinear	(	SCIP *	scip,
		SCIP_EXPR *	expr,
		SCIP_SOL *	sol,
		SCIP_Longint	soltag,
		SCIP_Real *	viol,
		SCIP_Bool *	violunder,
		SCIP_Bool *	violover )

computes absolute violation for auxvar relation in an expression w.r.t. original variables

Assume the expression is f(x), where x are original (i.e., not auxiliary) variables. Assume that f(x) is associated with auxiliary variable z.

If there are negative locks, then returns the violation of z ≤ f(x) and sets violover to TRUE. If there are positive locks, then returns the violation of z ≥ f(x) and sets violunder to TRUE. Of course, if there both negative and positive locks, then return the violation of z = f(x).

If necessary, f is evaluated in the given solution. If that fails (domain error), then viol is set to SCIPinfinity() and both violover and violunder are set to TRUE.

Parameters

scip	SCIP data structure
expr	expression
sol	solution
soltag	tag of solution
viol	buffer to store computed violation
violunder	buffer to store whether z >= f(x) is violated, or NULL
violover	buffer to store whether z <= f(x) is violated, or NULL

Definition at line 14773 of file cons_nonlinear.c.

References assert(), getExprAbsOrigViolation(), NULL, SCIP_Bool, SCIP_CALL, SCIP_Longint, SCIP_OKAY, SCIP_Real, SCIPevalExpr(), and sol.

SCIPgetExprAbsAuxViolationNonlinear()

SCIP_RETCODE SCIPgetExprAbsAuxViolationNonlinear	(	SCIP *	scip,
		SCIP_EXPR *	expr,
		SCIP_Real	auxvalue,
		SCIP_SOL *	sol,
		SCIP_Real *	viol,
		SCIP_Bool *	violunder,
		SCIP_Bool *	violover )

computes absolute violation for auxvar relation in an expression w.r.t. auxiliary variables

Assume the expression is f(w), where w are auxiliary variables that were introduced by some nlhdlr. Assume that f(w) is associated with auxiliary variable z.

If there are negative locks, then returns the violation of z ≤ f(w) and sets violover to TRUE. If there are positive locks, then returns the violation of z ≥ f(w) and sets violunder to TRUE. Of course, if there both negative and positive locks, then return the violation of z = f(w).

If the given value of f(w) is SCIP_INVALID, then viol is set to SCIPinfinity() and both violover and violunder are set to TRUE.

Parameters

scip	SCIP data structure
expr	expression
auxvalue	the value of f(w)
sol	solution that has been evaluated
viol	buffer to store computed violation
violunder	buffer to store whether z >= f(w) is violated, or NULL
violover	buffer to store whether z <= f(w) is violated, or NULL

Definition at line 14808 of file cons_nonlinear.c.

References assert(), getExprAbsAuxViolation(), NULL, SCIP_Bool, SCIP_OKAY, SCIP_Real, and sol.

Referenced by SCIP_DECL_NLHDLRENFO(), SCIP_DECL_NLHDLRESTIMATE(), and SCIP_DECL_NLHDLRESTIMATE().

SCIPgetExprRelAuxViolationNonlinear()

SCIP_RETCODE SCIPgetExprRelAuxViolationNonlinear	(	SCIP *	scip,
		SCIP_EXPR *	expr,
		SCIP_Real	auxvalue,
		SCIP_SOL *	sol,
		SCIP_Real *	viol,
		SCIP_Bool *	violunder,
		SCIP_Bool *	violover )

computes relative violation for auxvar relation in an expression w.r.t. auxiliary variables

Assume the expression is f(w), where w are auxiliary variables that were introduced by some nlhdlr. Assume that f(w) is associated with auxiliary variable z.

Taking the absolute violation from SCIPgetExprAbsAuxViolationNonlinear(), this function returns the absolute violation divided by max(1,|f(w)|).

If the given value of f(w) is SCIP_INVALID, then viol is set to SCIPinfinity() and both violover and violunder are set to TRUE.

Parameters

scip	SCIP data structure
expr	expression
auxvalue	the value of f(w)
sol	solution that has been evaluated
viol	buffer to store computed violation
violunder	buffer to store whether z >= f(w) is violated, or NULL
violover	buffer to store whether z <= f(w) is violated, or NULL

Definition at line 14840 of file cons_nonlinear.c.

References assert(), getExprAbsAuxViolation(), MAX, NULL, REALABS, SCIP_Bool, SCIP_INVALID, SCIP_OKAY, SCIP_Real, SCIPisInfinity(), and sol.

Referenced by SCIP_DECL_NLHDLRESTIMATE(), SCIP_DECL_NLHDLRESTIMATE(), and SCIPprocessRowprepNonlinear().

SCIPgetExprBoundsNonlinear()

SCIP_INTERVAL SCIPgetExprBoundsNonlinear	(	SCIP *	scip,
		SCIP_EXPR *	expr )

returns bounds on the expression

This gives an intersection of bounds from

• activity calculation (SCIPexprGetActivity()), if valid,
• auxiliary variable, if present,
• stored by SCIPtightenExprIntervalNonlinear() during domain propagation

Note

The returned interval can be empty!

Parameters

scip	SCIP data structure
expr	expression

Definition at line 14876 of file cons_nonlinear.c.

References assert(), NULL, SCIP_INTERVAL_INFINITY, SCIPconshdlrGetData(), SCIPepsilon(), SCIPexprGetActivity(), SCIPexprGetActivityTag(), SCIPexprGetOwnerData(), SCIPintervalIntersectEps(), and SCIPintervalSetEntire().

Referenced by getFeasiblePointsBilinear(), propagateBoundsQuadExpr(), reversePropQueue(), SCIP_DECL_NLHDLRREVERSEPROP(), SCIP_DECL_NLHDLRREVERSEPROP(), SCIP_DECL_NLHDLRREVERSEPROP(), and SCIP_DECL_NLHDLRREVERSEPROP().

SCIPtightenExprIntervalNonlinear()

SCIP_RETCODE SCIPtightenExprIntervalNonlinear	(	SCIP *	scip,
		SCIP_EXPR *	expr,
		SCIP_INTERVAL	newbounds,
		SCIP_Bool *	cutoff,
		int *	ntightenings )

informs the expression about new bounds that can be used for reverse-propagation and to tighten bounds of corresponding (auxiliary) variable (if any)

Attention

this function should only be called during domain propagation in cons_nonlinear

Parameters

scip	SCIP data structure
expr	expression to be tightened
newbounds	new bounds for the expression
cutoff	buffer to store whether a cutoff was detected
ntightenings	buffer to add the total number of tightenings, or NULL

Definition at line 14932 of file cons_nonlinear.c.

References assert(), cutoff, FALSE, SCIP_Interval::inf, isIntervalBetter(), NULL, SCIP_Bool, SCIP_CALL, SCIP_INTERVAL_INFINITY, SCIP_OKAY, SCIPceil(), SCIPconshdlrGetData(), SCIPdebugMsg, SCIPdebugMsgPrint, SCIPepsilon(), SCIPexprGetActivity(), SCIPexprGetActivityTag(), SCIPexprGetHdlr(), SCIPexprGetNChildren(), SCIPexprGetOwnerData(), SCIPexprhdlrGetName(), SCIPexprIsIntegral(), SCIPfloor(), SCIPintervalIntersectEps(), SCIPintervalIsEmpty(), SCIPintervalIsEntire(), SCIPisInfinity(), SCIPprintExpr(), SCIPqueueInsert(), SCIP_Interval::sup, tightenAuxVarBounds(), and TRUE.

Referenced by propagateBoundsLinExpr(), propagateBoundsQuadExpr(), propConss(), reversePropagateLinearExpr(), reversePropQueue(), SCIP_DECL_NLHDLRREVERSEPROP(), SCIP_DECL_NLHDLRREVERSEPROP(), and SCIP_DECL_NLHDLRREVERSEPROP().

SCIPmarkExprPropagateNonlinear()

SCIP_RETCODE SCIPmarkExprPropagateNonlinear	(	SCIP *	scip,
		SCIP_EXPR *	expr )

mark constraints that include this expression to be propagated again

This can be used by, e.g., nlhdlrs, to trigger a new propagation of constraints without a change of variable bounds, e.g., because new information on the expression is available that could potentially lead to tighter expression activity values.

Note, that this call marks also constraints for propagation which only share some variable with this expression.

Parameters

scip	SCIP data structure
expr	expression to propagate again

Definition at line 15078 of file cons_nonlinear.c.

References assert(), c, FALSE, NULL, SCIP_CALL, SCIP_EXPRITER_DFS, SCIP_OKAY, SCIPconsGetData(), SCIPcreateExpriter(), SCIPexprGetOwnerData(), SCIPexpriterGetNext(), SCIPexpriterInit(), SCIPexpriterIsEnd(), SCIPfreeExpriter(), SCIPincrementCurBoundsTagNonlinear(), and SCIPisExprVar().

Referenced by SCIPaddIneqBilinear().

SCIPaddExprViolScoreNonlinear()

void SCIPaddExprViolScoreNonlinear	(	SCIP *	scip,
		SCIP_EXPR *	expr,
		SCIP_Real	violscore )

adds violation-branching score to an expression

Adds a score to the expression-specific violation-branching score, thereby marking it as branching candidate. The expression must either be a variable expression or have an aux-variable. In the latter case, branching on auxiliary variables must have been enabled. In case of doubt, use SCIPaddExprsViolScoreNonlinear(). Roughly, the difference between these functions is that the current function adds violscore to the expression directly, while SCIPaddExprsViolScoreNonlinear() will split the violation score among all the given expressions according to parameter constraints/nonlinear/branching/violsplit.

See also

SCIPaddExprsViolScoreNonlinear()

Parameters

scip	SCIP data structure
expr	expression where to add branching score
violscore	violation score to add to expression

Definition at line 15131 of file cons_nonlinear.c.

References assert(), branchAuxNonlinear(), NULL, SCIP_Real, SCIPconshdlrGetData(), SCIPexprGetOwnerData(), and SCIPisExprVar().

Referenced by addExprsViolScore().

SCIPaddExprsViolScoreNonlinear()

SCIP_RETCODE SCIPaddExprsViolScoreNonlinear	(	SCIP *	scip,
		SCIP_EXPR **	exprs,
		int	nexprs,
		SCIP_Real	violscore,
		SCIP_SOL *	sol,
		SCIP_Bool *	success )

adds violation-branching score to a set of expressions, distributing the score among all the expressions

Each expression must either be a variable expression or have an aux-variable. If branching on aux-variables is disabled, then the violation branching score will be distributed among all variables present in exprs.

Parameters

scip	SCIP data structure
exprs	expressions where to add branching score
nexprs	number of expressions
violscore	violation score to add to expression
sol	current solution
success	buffer to store whether at least one violscore was added

Definition at line 15177 of file cons_nonlinear.c.

References addExprsViolScore(), assert(), branchAuxNonlinear(), FALSE, i, NULL, nvars, SCIP_Bool, SCIP_CALL, SCIP_EXPRITER_DFS, SCIP_OKAY, SCIP_Real, SCIPallocBufferArray, SCIPcalcMemGrowSize(), SCIPcreateExpriter(), SCIPexprGetOwnerData(), SCIPexpriterGetNext(), SCIPexpriterInit(), SCIPexpriterIsEnd(), SCIPexpriterRestartDFS(), SCIPfreeBufferArray, SCIPfreeExpriter(), SCIPisExprVar(), SCIPreallocBufferArray, and sol.

Referenced by addExprViolScoresAuxVars(), SCIP_DECL_NLHDLRESTIMATE(), SCIP_DECL_NLHDLRESTIMATE(), and SCIP_DECL_NLHDLRESTIMATE().

SCIPgetExprViolScoreNonlinear()

SCIP_Real SCIPgetExprViolScoreNonlinear

(

SCIP_EXPR *

expr

)

gives violation-branching score stored in expression, or 0.0 if no valid score has been stored

Parameters

expr	expression

Definition at line 15248 of file cons_nonlinear.c.

References assert(), NULL, SCIP_INVALID, SCIP_Real, SCIPABORT, SCIPconshdlrGetData(), SCIPerrorMessage, and SCIPexprGetOwnerData().

Referenced by collectBranchingCandidates(), and registerBranchingCandidates().

SCIPgetExprPartialDiffNonlinear()

SCIP_Real SCIPgetExprPartialDiffNonlinear	(	SCIP *	scip,
		SCIP_EXPR *	expr,
		SCIP_VAR *	var )

returns the partial derivative of an expression w.r.t. a variable (or SCIP_INVALID if there was an evaluation error)

See also

SCIPexprGetDerivative()

Parameters

scip	SCIP data structure
expr	root expression of constraint used in the last SCIPevalExprGradient() call
var	variable (needs to be in the expression)

Definition at line 15294 of file cons_nonlinear.c.

References assert(), NULL, SCIP_INVALID, SCIP_Real, SCIPconshdlrGetData(), SCIPexprGetDerivative(), SCIPexprGetDiffTag(), SCIPexprGetOwnerData(), SCIPhashmapExists(), SCIPhashmapGetImage(), SCIPisExprValue(), SCIPisExprVar(), and var.

SCIPgetExprPartialDiffGradientDirNonlinear()

SCIP_Real SCIPgetExprPartialDiffGradientDirNonlinear	(	SCIP *	scip,
		SCIP_EXPR *	expr,
		SCIP_VAR *	var )

returns the var's coordinate of Hu partial derivative of an expression w.r.t. a variable (or SCIP_INVALID if there was an evaluation error)

See also

SCIPexprGetBardot()

Parameters

scip	SCIP data structure
expr	root expression of constraint used in the last SCIPevalExprHessianDir() call
var	variable (needs to be in the expression)

Definition at line 15340 of file cons_nonlinear.c.

References assert(), NULL, SCIP_INVALID, SCIP_Real, SCIPconshdlrGetData(), SCIPexprGetBardot(), SCIPexprGetDiffTag(), SCIPexprGetOwnerData(), SCIPhashmapExists(), SCIPhashmapGetImage(), SCIPisExprValue(), SCIPisExprVar(), and var.

SCIPevalExprQuadraticAuxNonlinear()

SCIP_Real SCIPevalExprQuadraticAuxNonlinear	(	SCIP *	scip,
		SCIP_EXPR *	expr,
		SCIP_SOL *	sol )

evaluates quadratic term in a solution w.r.t. auxiliary variables

Note

This requires that for every expr used in the quadratic data, a variable or auxiliary variable is available.

Parameters

scip	SCIP data structure
expr	quadratic expression
sol	solution to evaluate, or NULL for LP solution

Definition at line 15386 of file cons_nonlinear.c.

References assert(), i, NULL, SCIP_Real, SCIPexprGetQuadraticBilinTerm(), SCIPexprGetQuadraticData(), SCIPexprGetQuadraticQuadTerm(), SCIPgetExprAuxVarNonlinear(), SCIPgetSolVal(), and sol.

SCIPcreateConsOr()

SCIP_RETCODE SCIPcreateConsOr	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_VAR *	resvar,
		int	nvars,
		SCIP_VAR **	vars,
		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 )

creates and captures an or constraint

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
resvar	resultant variable of the operation
nvars	number of operator variables in the constraint
vars	array with operator variables of constraint
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 2212 of file cons_or.c.

References assert(), consdataCreate(), CONSHDLR_NAME, i, NULL, nvars, propagate, SCIP_Bool, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIPconshdlrGetData(), SCIPcreateCons(), SCIPerrorMessage, SCIPfindConshdlr(), SCIPvarGetName(), SCIPvarIsBinary(), separate(), and vars.

Referenced by CREATE_CONSTRAINT(), SCIP_DECL_CONSCOPY(), SCIP_DECL_CONSPARSE(), and SCIPcreateConsBasicOr().

SCIPcreateConsBasicOr()

SCIP_RETCODE SCIPcreateConsBasicOr	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_VAR *	resvar,
		int	nvars,
		SCIP_VAR **	vars )

creates and captures an or constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsNonlinear(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h

See also

SCIPcreateConsOr() for information about the basic constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

creates and captures an or constraint in its most basic variant, i. e., with all constraint flags set to their default values

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
resvar	resultant variable of the operation
nvars	number of operator variables in the constraint
vars	array with operator variables of constraint

Definition at line 2293 of file cons_or.c.

References FALSE, nvars, SCIP_CALL, SCIP_OKAY, SCIPcreateConsOr(), TRUE, and vars.

Referenced by AMPLProblemHandler::OnBinaryLogical().

SCIPgetNVarsOr()

int SCIPgetNVarsOr	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets number of variables in or constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 2309 of file cons_or.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by matrixCreate(), and SCIP_DECL_CONSCOPY().

SCIPgetVarsOr()

SCIP_VAR ** SCIPgetVarsOr	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets array of variables in or constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 2332 of file cons_or.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by matrixCreate(), and SCIP_DECL_CONSCOPY().

SCIPgetResultantOr()

SCIP_VAR * SCIPgetResultantOr	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets the resultant variable in or constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 2355 of file cons_or.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by matrixCreate(), and SCIP_DECL_CONSCOPY().

SCIPcheckSolutionOrbisack()

SCIP_RETCODE SCIPcheckSolutionOrbisack	(	SCIP *	scip,
		SCIP_SOL *	sol,
		SCIP_VAR **	vars1,
		SCIP_VAR **	vars2,
		int	nrows,
		SCIP_Bool	printreason,
		SCIP_Bool *	feasible )

checks whether a given binary solution is feasible for the orbisack

checks given solution for feasibility

Parameters

scip	SCIP data structure
sol	solution to check for feasibility
vars1	variables of first column
vars2	variables of second column
nrows	number of rows
printreason	whether reason for infeasibility should be printed
feasible	memory address to store whether sol is feasible

Definition at line 2134 of file cons_orbisack.c.

References assert(), FALSE, i, NULL, SCIP_Bool, SCIP_OKAY, SCIPgetSolVal(), SCIPinfoMessage(), SCIPisFeasIntegral(), sol, and TRUE.

Referenced by checkFullOrbitopeSolution(), SCIP_DECL_CONSCHECK(), and SCIP_DECL_CONSENFOPS().

SCIPcreateConsOrbisack()

SCIP_RETCODE SCIPcreateConsOrbisack	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_VAR *const *	vars1,
		SCIP_VAR *const *	vars2,
		int	nrows,
		SCIP_Bool	ispporbisack,
		SCIP_Bool	isparttype,
		SCIP_Bool	ismodelcons,
		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 )

creates and captures a orbisack constraint

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
vars1	first column of matrix of variables on which the symmetry acts
vars2	second column of matrix of variables on which the symmetry acts
nrows	number of rows in variable matrix
ispporbisack	whether the orbisack is a packing/partitioning orbisack
isparttype	whether the orbisack is a partitioning orbisack
ismodelcons	whether the orbisack is a model constraint
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 2308 of file cons_orbisack.c.

References assert(), consdataCreate(), CONSHDLR_NAME, FALSE, i, NULL, packingUpgrade(), propagate, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_ORBITOPETYPE_PACKING, SCIP_ORBITOPETYPE_PARTITIONING, SCIP_PLUGINNOTFOUND, SCIPallocBufferArray, SCIPconshdlrGetData(), SCIPcreateCons(), SCIPcreateConsOrbitope(), SCIPerrorMessage, SCIPfindConshdlr(), SCIPfreeBufferArray, separate(), TRUE, and vars.

Referenced by orbisackUpgrade(), SCIP_DECL_CONSCOPY(), and SCIPcreateConsBasicOrbisack().

SCIPcreateConsBasicOrbisack()

SCIP_RETCODE SCIPcreateConsBasicOrbisack	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_VAR **	vars1,
		SCIP_VAR **	vars2,
		int	nrows,
		SCIP_Bool	ispporbisack,
		SCIP_Bool	isparttype,
		SCIP_Bool	ismodelcons )

creates and captures an orbisack constraint in its most basic variant

All constraint flags set to their default values, which can be set afterwards using SCIPsetConsFLAGNAME() in scip.h.

See also

SCIPcreateConsOrbisack() for the default constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

creates and captures an orbisack constraint in its most basic variant

All constraint flags set to their default values, which can be set afterwards using SCIPsetConsFLAGNAME() in scip.h.

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
vars1	first column of matrix of variables on which the symmetry acts
vars2	second column of matrix of variables on which the symmetry acts
nrows	number of rows in constraint matrix
ispporbisack	whether the orbisack is a packing/partitioning orbisack
isparttype	whether the orbisack is a partitioning orbisack
ismodelcons	whether the orbisack is a model constraint

Definition at line 2415 of file cons_orbisack.c.

References FALSE, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIPcreateConsOrbisack(), and TRUE.

Referenced by SCIP_DECL_CONSPARSE().

SCIPcreateConsOrbitopeFull()

SCIP_RETCODE SCIPcreateConsOrbitopeFull	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_VAR ***	vars,
		int	nrows,
		int	ncols,
		SCIP_Bool	resolveprop,
		SCIP_Bool	ismodelcons,
		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 )

creates and captures a full orbitope constraint

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
vars	matrix of variables on which the symmetry acts
nrows	number of set partitioning/packing constraints <=> p
ncols	number of symmetric variable blocks <=> q
resolveprop	should propagation be resolved?
ismodelcons	whether the orbitope is a model constraint
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 1860 of file cons_orbitope_full.c.

References assert(), consdataCreate(), CONSHDLR_NAME, i, NULL, obj, propagate, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIP_Real, SCIPcreateCons(), SCIPerrorMessage, SCIPfindConshdlr(), SCIPgetSubscipDepth(), SCIPinfinity(), SCIPisEQ(), SCIPisInfinity(), SCIPisZero(), SCIPvarGetLbGlobal(), SCIPvarGetNegatedVar(), SCIPvarGetObj(), SCIPvarGetUbGlobal(), SCIPvarIsActive(), SCIPvarIsBinary(), SCIPvarIsNegated(), separate(), var, and vars.

Referenced by SCIP_DECL_CONSCOPY(), SCIP_DECL_CONSPARSE(), SCIPcreateConsBasicOrbitopeFull(), and SCIPcreateConsOrbitope().

SCIPcreateConsBasicOrbitopeFull()

SCIP_RETCODE SCIPcreateConsBasicOrbitopeFull	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_VAR ***	vars,
		int	nrows,
		int	ncols,
		SCIP_Bool	resolveprop,
		SCIP_Bool	ismodelcons )

creates and captures a full orbitope constraint in its most basic variant, i. e., with all constraint flags set to their default values, which can be set afterwards using SCIPsetConsFLAGNAME()

See also

SCIPcreateConsOrbitopeFull() for the default constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
vars	matrix of variables on which the symmetry acts
nrows	number of set partitioning/packing constraints <=> p
ncols	number of symmetric variable blocks <=> q
resolveprop	should propagation be resolved?
ismodelcons	whether the orbitope is a model constraint

Definition at line 1970 of file cons_orbitope_full.c.

References FALSE, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIPcreateConsOrbitopeFull(), TRUE, and vars.

SCIPcreateConsOrbitopePP()

SCIP_RETCODE SCIPcreateConsOrbitopePP	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_VAR ***	vars,
		SCIP_ORBITOPETYPE	orbitopetype,
		int	nrows,
		int	ncols,
		SCIP_Bool	resolveprop,
		SCIP_Bool	ismodelcons,
		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 )

creates and captures a packing/partitioning orbitope constraint

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

creates and captures a packing/partitioning orbitope constraint

Precondition

This constraint handler assumes that constraints which enforce the packing/partitioning constraints are contained in the problem. It does not implement, e.g., separation and propagation of set packing/partitioning constraints, since this would just copy large parts of the code of the setppc constraint handler.

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
vars	matrix of variables on which the symmetry acts
orbitopetype	type of orbitope constraint
nrows	number of rows in orbitope matrix <=> p
ncols	number of columns in orbitope matrix <=> q
resolveprop	should propagation be resolved?
ismodelcons	whether the orbitope is a model constraint
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 2700 of file cons_orbitope_pp.c.

References assert(), consdataCreate(), CONSHDLR_NAME, i, NULL, obj, propagate, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIP_Real, SCIPcreateCons(), SCIPerrorMessage, SCIPfindConshdlr(), SCIPgetSubscipDepth(), SCIPinfinity(), SCIPisEQ(), SCIPisInfinity(), SCIPisZero(), SCIPvarGetLbGlobal(), SCIPvarGetNegatedVar(), SCIPvarGetObj(), SCIPvarGetUbGlobal(), SCIPvarIsActive(), SCIPvarIsBinary(), SCIPvarIsNegated(), separate(), var, and vars.

Referenced by SCIP_DECL_CONSCOPY(), SCIP_DECL_CONSPARSE(), SCIPcreateConsBasicOrbitopePP(), and SCIPcreateConsOrbitope().

SCIPcreateConsBasicOrbitopePP()

SCIP_RETCODE SCIPcreateConsBasicOrbitopePP	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_VAR ***	vars,
		SCIP_ORBITOPETYPE	orbitopetype,
		int	nrows,
		int	ncols,
		SCIP_Bool	resolveprop,
		SCIP_Bool	ismodelcons )

creates and captures a packing/partitioning orbitope constraint in its most basic variant, i. e., with all constraint flags set to their default values, which can be set afterwards using SCIPsetConsFLAGNAME()

See also

SCIPcreateConsOrbitopePP() for the default constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
vars	matrix of variables on which the symmetry acts
orbitopetype	type of orbitope constraint
nrows	number of rows in orbitope matrix <=> p
ncols	number of columns in orbitope matrix <=> q
resolveprop	should propagation be resolved?
ismodelcons	whether the orbitope is a model constraint

Definition at line 2810 of file cons_orbitope_pp.c.

References FALSE, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIPcreateConsOrbitopePP(), TRUE, and vars.

SCIPcreateConsPseudobooleanWithConss()

SCIP_RETCODE SCIPcreateConsPseudobooleanWithConss	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_CONS *	lincons,
		SCIP_LINEARCONSTYPE	linconstype,
		SCIP_CONS **	andconss,
		SCIP_Real *	andcoefs,
		int	nandconss,
		SCIP_VAR *	indvar,
		SCIP_Real	weight,
		SCIP_Bool	issoftcons,
		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 )

creates and captures a pseudoboolean constraint, with given linear and and-constraints

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
lincons	associated linear constraint
linconstype	linear constraint type of associated linear constraint
andconss	associated and-constraints
andcoefs	associated coefficients of and-constraints
nandconss	number of associated and-constraints
indvar	indicator variable if it's a soft constraint, or NULL
weight	weight of the soft constraint, if it is one
issoftcons	is this a soft constraint
lhs	left hand side of constraint
rhs	right hand side of constraint
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are seperated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 9408 of file cons_pseudoboolean.c.

References assert(), BMScopyMemoryArray, c, ConsAndData::cons, consdataCreate(), CONSHDLR_NAME, FALSE, inithashmapandtable(), ConsAndData::isoriginal, ConsAndData::istransformed, ConsAndData::newvars, ConsAndData::nnewvars, ConsAndData::noriguses, NULL, ConsAndData::nuses, ConsAndData::nvars, nvars, ConsAndData::origcons, propagate, SCIP_Bool, SCIP_CALL, SCIP_INVALIDDATA, SCIP_LINEARCONSTYPE_INVALIDCONS, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIP_Real, SCIPallocBlockMemory, SCIPcalcMemGrowSize(), SCIPcaptureCons(), SCIPcaptureVar(), SCIPconsAddUpgradeLocks(), SCIPconshdlrGetData(), SCIPconsIsTransformed(), SCIPcreateCons(), SCIPduplicateBlockMemoryArray, SCIPensureBlockMemoryArray, SCIPerrorMessage, SCIPfindConshdlr(), SCIPfreeBlockMemory, SCIPfreeBlockMemoryArray, SCIPgetNVarsAnd(), SCIPgetResultantAnd(), SCIPgetVarsAnd(), SCIPhashmapExists(), SCIPhashmapInsert(), SCIPhashtableInsert(), SCIPhashtableRetrieve(), SCIPinfinity(), SCIPisInfinity(), SCIPsortPtr(), SCIPwarningMessage(), separate(), ConsAndData::snewvars, ConsAndData::svars, TRUE, ConsAndData::vars, and vars.

Referenced by copyConsPseudoboolean().

SCIPcreateConsPseudoboolean()

SCIP_RETCODE SCIPcreateConsPseudoboolean	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_VAR **	linvars,
		int	nlinvars,
		SCIP_Real *	linvals,
		SCIP_VAR ***	terms,
		int	nterms,
		int *	ntermvars,
		SCIP_Real *	termvals,
		SCIP_VAR *	indvar,
		SCIP_Real	weight,
		SCIP_Bool	issoftcons,
		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 )

creates and captures a pseudoboolean constraint

Note

linear and nonlinear terms can be added using SCIPaddCoefPseudoboolean() and SCIPaddTermPseudoboolean(), respectively

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
linvars	variables of the linear part, or NULL
nlinvars	number of variables of the linear part
linvals	coefficients of linear part, or NULL
terms	nonlinear terms of variables, or NULL
nterms	number of terms of variables of nonlinear term
ntermvars	number of variables in nonlinear terms, or NULL
termvals	coefficients of nonlinear parts, or NULL
indvar	indicator variable if it's a soft constraint, or NULL
weight	weight of the soft constraint, if it is one
issoftcons	is this a soft constraint
lhs	left hand side of constraint
rhs	right hand side of constraint
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 9699 of file cons_pseudoboolean.c.

References assert(), c, consdataCreate(), CONSHDLR_NAME, createAndAddAnds(), createAndAddLinearCons(), FALSE, inithashmapandtable(), nterms, NULL, propagate, REALABS, SCIP_Bool, SCIP_CALL, SCIP_INVALIDDATA, SCIP_LINEARCONSTYPE_INVALIDCONS, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIP_Real, SCIPallocBufferArray, SCIPconshdlrGetData(), SCIPcreateCons(), SCIPerrorMessage, SCIPfindConshdlr(), SCIPfreeBufferArray, SCIPgetResultantAnd(), SCIPinfinity(), SCIPisFinite, SCIPisInfinity(), SCIPisZero(), and separate().

Referenced by readConstraints(), SCIP_DECL_CONSPARSE(), and SCIPcreateConsBasicPseudoboolean().

SCIPcreateConsBasicPseudoboolean()

SCIP_RETCODE SCIPcreateConsBasicPseudoboolean	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_VAR **	linvars,
		int	nlinvars,
		SCIP_Real *	linvals,
		SCIP_VAR ***	terms,
		int	nterms,
		int *	ntermvars,
		SCIP_Real *	termvals,
		SCIP_VAR *	indvar,
		SCIP_Real	weight,
		SCIP_Bool	issoftcons,
		SCIP_Real	lhs,
		SCIP_Real	rhs )

creates and captures a pseudoboolean constraint in its most basic variant, i. e., with all constraint flags set to their default values, which can be set afterwards using SCIPsetConsFLAGNAME() in scip.h

See also

SCIPcreateConsPseudoboolean() for the default constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
linvars	variables of the linear part, or NULL
nlinvars	number of variables of the linear part
linvals	coefficients of linear part, or NULL
terms	nonlinear terms of variables, or NULL
nterms	number of terms of variables of nonlinear term
ntermvars	number of variables in nonlinear terms, or NULL
termvals	coefficients of nonlinear parts, or NULL
indvar	indicator variable if it's a soft constraint, or NULL
weight	weight of the soft constraint, if it is one
issoftcons	is this a soft constraint
lhs	left hand side of constraint
rhs	right hand side of constraint

Definition at line 9889 of file cons_pseudoboolean.c.

References FALSE, nterms, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPcreateConsPseudoboolean(), and TRUE.

SCIPaddCoefPseudoboolean()

SCIP_RETCODE SCIPaddCoefPseudoboolean	(	SCIP *const	scip,
		SCIP_CONS *const	cons,
		SCIP_VAR *const	var,
		SCIP_Real const	val )

adds a variable to the pseudo boolean constraint (if it is not zero)

Note

you can only add a coefficient if the special type of linear constraint won't changed

adds a variable to the pseudo boolean constraint (if it is not zero)

Note

you can only add a coefficient if the special type of linear constraint won't changed

Parameters

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

Definition at line 9921 of file cons_pseudoboolean.c.

References assert(), CONSHDLR_NAME, FALSE, NULL, REALABS, SCIP_CALL, SCIP_INVALIDDATA, SCIP_LINEARCONSTYPE_INVALIDCONS, SCIP_LINEARCONSTYPE_KNAPSACK, SCIP_LINEARCONSTYPE_LINEAR, SCIP_LINEARCONSTYPE_LOGICOR, SCIP_LINEARCONSTYPE_SETPPC, SCIP_Longint, SCIP_OKAY, SCIP_Real, SCIPABORT, SCIPaddCoefKnapsack(), SCIPaddCoefLinear(), SCIPaddCoefLogicor(), SCIPaddCoefSetppc(), SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPerrorMessage, SCIPisEQ(), SCIPisFinite, SCIPisInfinity(), SCIPisIntegral(), SCIPisPositive(), SCIPisZero(), and var.

SCIPaddTermPseudoboolean()

SCIP_RETCODE SCIPaddTermPseudoboolean	(	SCIP *const	scip,
		SCIP_CONS *const	cons,
		SCIP_VAR **const	vars,
		int const	nvars,
		SCIP_Real const	val )

adds nonlinear term to pseudo boolean constraint (if it is not zero)

Note

you can only add a coefficient if the special type of linear constraint won't changed

adds nonlinear term to pseudo boolean constraint (if it is not zero)

Note

you can only add a coefficient if the special type of linear constraint won't changed

Parameters

scip	SCIP data structure
cons	pseudoboolean constraint
vars	variables of the nonlinear term
nvars	number of variables of the nonlinear term
val	coefficient of constraint entry

Definition at line 10005 of file cons_pseudoboolean.c.

References addCoefTerm(), assert(), CONSHDLR_NAME, NULL, nvars, REALABS, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_Real, SCIPABORT, SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPerrorMessage, SCIPisFinite, SCIPisInfinity(), SCIPisZero(), and vars.

SCIPgetIndVarPseudoboolean()

SCIP_VAR * SCIPgetIndVarPseudoboolean	(	SCIP *const	scip,
		SCIP_CONS *const	cons )

gets indicator variable of pseudoboolean constraint, or NULL if there is no

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 10043 of file cons_pseudoboolean.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by addSymmetryInformation(), determineTotalNumberLinearConss(), fromCommandLine(), and writeOpbConstraints().

SCIPgetLinearConsPseudoboolean()

SCIP_CONS * SCIPgetLinearConsPseudoboolean	(	SCIP *const	scip,
		SCIP_CONS *const	cons )

gets linear constraint of pseudoboolean constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 10067 of file cons_pseudoboolean.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by addSymmetryInformation(), and writeOpbConstraints().

SCIPgetLinearConsTypePseudoboolean()

SCIP_LINEARCONSTYPE SCIPgetLinearConsTypePseudoboolean	(	SCIP *const	scip,
		SCIP_CONS *const	cons )

gets type of linear constraint of pseudoboolean constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 10091 of file cons_pseudoboolean.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_LINEARCONSTYPE_INVALIDCONS, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by addSymmetryInformation().

SCIPgetNLinVarsWithoutAndPseudoboolean()

int SCIPgetNLinVarsWithoutAndPseudoboolean	(	SCIP *const	scip,
		SCIP_CONS *const	cons )

gets number of linear variables without artificial terms variables of pseudoboolean constraint

Parameters

scip	SCIP data structure
cons	pseudoboolean constraint

Definition at line 10115 of file cons_pseudoboolean.c.

References assert(), checkConsConsistency, CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

SCIPgetLinDatasWithoutAndPseudoboolean()

SCIP_RETCODE SCIPgetLinDatasWithoutAndPseudoboolean	(	SCIP *const	scip,
		SCIP_CONS *const	cons,
		SCIP_VAR **const	linvars,
		SCIP_Real *const	lincoefs,
		int *const	nlinvars )

gets linear constraint of pseudoboolean constraint

Parameters

scip	SCIP data structure
cons	pseudoboolean constraint
linvars	array to store and-constraints
lincoefs	array to store and-coefficients
nlinvars	pointer to store the required array size for and-constraints, have to be initialized with size of given array

Definition at line 10141 of file cons_pseudoboolean.c.

References assert(), checkConsConsistency, CONSHDLR_NAME, getLinearConsNVars(), getLinearConsVarsData(), getLinVarsAndAndRess(), NULL, nvars, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_Real, SCIPABORT, SCIPallocBufferArray, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPerrorMessage, SCIPfreeBufferArray, and vars.

SCIPgetAndDatasPseudoboolean()

SCIP_RETCODE SCIPgetAndDatasPseudoboolean	(	SCIP *const	scip,
		SCIP_CONS *const	cons,
		SCIP_CONS **const	andconss,
		SCIP_Real *const	andcoefs,
		int *const	nandconss )

gets and-constraints of pseudoboolean constraint

Parameters

scip	SCIP data structure
cons	pseudoboolean constraint
andconss	array to store and-constraints
andcoefs	array to store and-coefficients
nandconss	pointer to store the required array size for and-constraints, have to be initialized with size of given array

Definition at line 10199 of file cons_pseudoboolean.c.

References assert(), c, checkConsConsistency, CONSHDLR_NAME, NULL, SCIP_Bool, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_Real, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPconsIsOriginal(), SCIPerrorMessage, and TRUE.

SCIPgetNAndsPseudoboolean()

int SCIPgetNAndsPseudoboolean	(	SCIP *const	scip,
		SCIP_CONS *const	cons )

gets number of and constraints of pseudoboolean constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 10257 of file cons_pseudoboolean.c.

References assert(), checkConsConsistency, CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

SCIPchgLhsPseudoboolean()

SCIP_RETCODE SCIPchgLhsPseudoboolean	(	SCIP *const	scip,
		SCIP_CONS *const	cons,
		SCIP_Real const	lhs )

changes left hand side of pseudoboolean constraint

Note

you can only change the left hand side if the special type of linear constraint won't changed

changes left hand side of pseudoboolean constraint

Note

you can only change the left hand side if the special type of linear constraint won't changed

Parameters

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

Definition at line 10289 of file cons_pseudoboolean.c.

References assert(), checkConsConsistency, chgLhs(), CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_INVALIDDATA, SCIP_LINEARCONSTYPE_INVALIDCONS, SCIP_LINEARCONSTYPE_KNAPSACK, SCIP_LINEARCONSTYPE_LINEAR, SCIP_LINEARCONSTYPE_LOGICOR, SCIP_LINEARCONSTYPE_SETPPC, SCIP_OKAY, SCIP_Real, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

SCIPchgRhsPseudoboolean()

SCIP_RETCODE SCIPchgRhsPseudoboolean	(	SCIP *const	scip,
		SCIP_CONS *const	cons,
		SCIP_Real const	rhs )

changes right hand side of pseudoboolean constraint

Note

you can only change the right hand side if the special type of linear constraint won't changed

changes right hand side of pseudoboolean constraint

Note

you can only change the right hand side if the special type of linear constraint won't changed

Parameters

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

Definition at line 10340 of file cons_pseudoboolean.c.

References assert(), checkConsConsistency, chgRhs(), CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_INVALIDDATA, SCIP_LINEARCONSTYPE_INVALIDCONS, SCIP_LINEARCONSTYPE_KNAPSACK, SCIP_LINEARCONSTYPE_LINEAR, SCIP_LINEARCONSTYPE_LOGICOR, SCIP_LINEARCONSTYPE_SETPPC, SCIP_OKAY, SCIP_Real, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

SCIPgetLhsPseudoboolean()

SCIP_Real SCIPgetLhsPseudoboolean	(	SCIP *const	scip,
		SCIP_CONS *const	cons )

get left hand side of pseudoboolean constraint

Parameters

scip	SCIP data structure
cons	pseudoboolean constraint

Definition at line 10382 of file cons_pseudoboolean.c.

References assert(), checkConsConsistency, CONSHDLR_NAME, NULL, SCIP_INVALID, SCIP_Real, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by addSymmetryInformation().

SCIPgetRhsPseudoboolean()

SCIP_Real SCIPgetRhsPseudoboolean	(	SCIP *const	scip,
		SCIP_CONS *const	cons )

get right hand side of pseudoboolean constraint

Parameters

scip	SCIP data structure
cons	pseudoboolean constraint

Definition at line 10407 of file cons_pseudoboolean.c.

References assert(), checkConsConsistency, CONSHDLR_NAME, NULL, SCIP_INVALID, SCIP_Real, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by addSymmetryInformation().

SCIPcreateConsSetpart()

SCIP_RETCODE SCIPcreateConsSetpart	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nvars,
		SCIP_VAR **	vars,
		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 )

creates and captures a set partitioning constraint

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nvars	number of variables in the constraint
vars	array with variables of constraint entries
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 9402 of file cons_setppc.c.

References createConsSetppc(), nvars, propagate, SCIP_Bool, SCIP_SETPPCTYPE_PARTITIONING, separate(), and vars.

Referenced by cliquePresolve(), cliquePresolve(), consdataLinearize(), createAndAddLinearCons(), createMipCpFormulation(), createProbQP(), createProbSimplified(), createProbSimplifiedTest(), extractGates(), processRealBoundChg(), SCIP_DECL_CONSPARSE(), SCIP_DECL_PRESOLEXEC(), and SCIPcreateConsBasicSetpart().

SCIPcreateConsBasicSetpart()

SCIP_RETCODE SCIPcreateConsBasicSetpart	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nvars,
		SCIP_VAR **	vars )

creates and captures a set partitioning constraint in its most basic variant, i. e., with all constraint flags set to their default values, which can be set afterwards using SCIPsetConsFLAGNAME() in scip.h

See also

SCIPcreateConsSetpart() for the default constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

creates and captures a set partitioning constraint with all constraint flags set to their default values

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nvars	number of variables in the constraint
vars	array with variables of constraint entries

Definition at line 9442 of file cons_setppc.c.

References FALSE, nvars, SCIP_CALL, SCIP_OKAY, SCIPcreateConsSetpart(), TRUE, and vars.

Referenced by createCipFormulation(), createMipFormulation(), and setupProblem().

SCIPcreateConsSetpack()

SCIP_RETCODE SCIPcreateConsSetpack	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nvars,
		SCIP_VAR **	vars,
		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 )

creates and captures a set packing constraint

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nvars	number of variables in the constraint
vars	array with variables of constraint entries
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 9460 of file cons_setppc.c.

References createConsSetppc(), nvars, propagate, SCIP_Bool, SCIP_SETPPCTYPE_PACKING, separate(), and vars.

Referenced by addCliques(), addExtraCliques(), cliquePresolve(), consdataLinearize(), createAndAddLinearCons(), deleteRedundantVars(), detectRedundantVars(), dualWeightsTightening(), fixDeleteOrUpgradeCons(), presolRoundConsSOS1(), removeConstraintsDueToNegCliques(), SCIP_DECL_CONFLICTEXEC(), SCIP_DECL_CONSPARSE(), SCIP_DECL_NONLINCONSUPGD(), SCIPcreateConsBasicSetpack(), tightenWeights(), upgradeCons(), upgradeCons(), and upgradeConss().

SCIPcreateConsBasicSetpack()

SCIP_RETCODE SCIPcreateConsBasicSetpack	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nvars,
		SCIP_VAR **	vars )

creates and captures a set packing constraint in its most basic variant, i. e., with all constraint flags set to their default values, which can be set afterwards using SCIPsetConsFLAGNAME() in scip.h

See also

SCIPcreateConsSetpack() for the default constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

creates and captures a set packing constraint with all constraint flags set to their default values

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nvars	number of variables in the constraint
vars	array with variables of constraint entries

Definition at line 9500 of file cons_setppc.c.

References FALSE, nvars, SCIP_CALL, SCIP_OKAY, SCIPcreateConsSetpack(), TRUE, and vars.

Referenced by createSetPackingCons().

SCIPcreateConsSetcover()

SCIP_RETCODE SCIPcreateConsSetcover	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nvars,
		SCIP_VAR **	vars,
		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 )

creates and captures a set covering constraint

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nvars	number of variables in the constraint
vars	array with variables of constraint entries
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 9518 of file cons_setppc.c.

References createConsSetppc(), nvars, propagate, SCIP_Bool, SCIP_SETPPCTYPE_COVERING, separate(), and vars.

Referenced by COLORprobSetUpArrayOfCons(), createAndAddLinearCons(), CUTOFF_CONSTRAINT(), CUTOFF_CONSTRAINT(), forbidCover(), forbidFixation(), processNlRow(), readCnf(), SCIP_DECL_CONFLICTEXEC(), SCIP_DECL_CONSPARSE(), and SCIPcreateConsBasicSetcover().

SCIPcreateConsBasicSetcover()

SCIP_RETCODE SCIPcreateConsBasicSetcover	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nvars,
		SCIP_VAR **	vars )

creates and captures a set packing constraint in its most basic variant, i. e., with all constraint flags set to their default values, which can be set afterwards using SCIPsetConsFLAGNAME() in scip.h

See also

SCIPcreateConsSetpack() for the default constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

creates and captures a set covering constraint with all constraint flags set to their default values

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nvars	number of variables in the constraint
vars	array with variables of constraint entries

Definition at line 9558 of file cons_setppc.c.

References FALSE, nvars, SCIP_CALL, SCIP_OKAY, SCIPcreateConsSetcover(), TRUE, and vars.

Referenced by SCIPprobdataCreate().

SCIPaddCoefSetppc()

SCIP_RETCODE SCIPaddCoefSetppc	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var )

adds coefficient in set partitioning / packing / covering constraint

Parameters

scip	SCIP data structure
cons	constraint data
var	variable to add to the constraint

Definition at line 9573 of file cons_setppc.c.

References addCoef(), assert(), CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPerrorMessage, and var.

Referenced by addCoefTerm(), cliquePresolve(), createCipFormulation(), createInitialColumns(), createMipCpFormulation(), createMipFormulation(), createProbQP(), createProbSimplified(), createProbSimplifiedTest(), createSetPackingCons(), doPricing(), SCIP_DECL_HEUREXEC(), SCIP_DECL_PRICERFARKAS(), SCIP_DECL_PRICERREDCOST(), SCIP_DECL_READERREAD(), SCIPaddCoefPseudoboolean(), and SCIPconsAddCoef().

SCIPgetNVarsSetppc()

int SCIPgetNVarsSetppc	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets number of variables in set partitioning / packing / covering constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 9596 of file cons_setppc.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by addSetppcConstraints(), addSymmetryInformation(), cleanupHashDatas(), componentPackingPartitioningOrbisackUpgrade(), correctPresoldata(), createAltLP(), createAltLP(), createPresoldata(), SCIPNLFeeder::FeedLinearConExpr(), getLinearConsNVars(), getLinearConsVarsData(), matrixCreate(), packingUpgrade(), presolveAddKKTSetppcConss(), SCIP_DECL_BRANCHEXECLP(), SCIP_DECL_CONSCOPY(), SCIP_DECL_PRESOLEXEC(), SCIPisPackingPartitioningOrbitope(), SCIPmatrixCreate(), SCIPwriteCcg(), SCIPwriteGms(), SCIPwriteLp(), SCIPwriteMps(), SCIPwritePbm(), SCIPwritePip(), SCIPwritePpm(), writeFzn(), writeOpbConstraints(), and writeOpbObjective().

SCIPgetVarsSetppc()

SCIP_VAR ** SCIPgetVarsSetppc	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets array of variables in set partitioning / packing / covering constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 9619 of file cons_setppc.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by addSetppcConstraints(), addSymmetryInformation(), componentPackingPartitioningOrbisackUpgrade(), correctPresoldata(), createAltLP(), createAltLP(), createPresoldata(), SCIPNLFeeder::FeedLinearConExpr(), getLinearConsVarsData(), matrixCreate(), packingUpgrade(), presolveAddKKTSetppcConss(), saveConsLinear(), SCIP_DECL_BRANCHEXECLP(), SCIP_DECL_CONSCOPY(), SCIP_DECL_PRESOLEXEC(), SCIPisPackingPartitioningOrbitope(), SCIPmatrixCreate(), SCIPwriteCcg(), SCIPwriteGms(), SCIPwriteLp(), SCIPwriteMps(), SCIPwritePbm(), SCIPwritePip(), SCIPwritePpm(), writeFzn(), writeOpbConstraints(), and writeOpbObjective().

SCIPgetTypeSetppc()

SCIP_SETPPCTYPE SCIPgetTypeSetppc	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets type of set partitioning / packing / covering constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 9642 of file cons_setppc.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by addNlrow(), addSetppcConstraints(), cleanupHashDatas(), componentPackingPartitioningOrbisackUpgrade(), correctPresoldata(), createAltLP(), createAltLP(), createPresoldata(), findAggregation(), fromCommandLine(), getLinearConsSides(), matrixCreate(), packingUpgrade(), presolveAddKKTSetppcConss(), saveConsLinear(), SCIP_DECL_CONSCOPY(), SCIP_DECL_PRESOLEXEC(), SCIPconsGetLhs(), SCIPconsGetRhs(), SCIPisPackingPartitioningOrbitope(), SCIPmatrixCreate(), SCIPwriteGms(), SCIPwriteLp(), SCIPwriteMps(), SCIPwritePip(), tryUpgradingSetppc(), writeFzn(), and writeOpbConstraints().

SCIPgetDualsolSetppc()

SCIP_Real SCIPgetDualsolSetppc	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets the dual solution of the set partitioning / packing / covering constraint in the current LP

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 9664 of file cons_setppc.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_INVALID, SCIP_Real, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPerrorMessage, and SCIProwGetDualsol().

Referenced by initPricing(), SCIP_DECL_PRICERREDCOST(), and SCIPconsGetDualsol().

SCIPgetDualfarkasSetppc()

SCIP_Real SCIPgetDualfarkasSetppc	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets the dual Farkas value of the set partitioning / packing / covering constraint in the current infeasible LP

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 9690 of file cons_setppc.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_INVALID, SCIP_Real, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPerrorMessage, and SCIProwGetDualfarkas().

Referenced by initPricing(), and SCIPconsGetDualfarkas().

SCIPgetRowSetppc()

SCIP_ROW * SCIPgetRowSetppc	(	SCIP *	scip,
		SCIP_CONS *	cons )

returns the linear relaxation of the given set partitioning / packing / covering constraint; may return NULL if no LP row was yet created; the user must not modify the row!

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 9718 of file cons_setppc.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by SCIPconsCreateRow(), and SCIPconsGetRow().

SCIPcreateRowSetppc()

SCIP_RETCODE SCIPcreateRowSetppc	(	SCIP *	scip,
		SCIP_CONS *	cons )

creates and returns the row of the given set partitioning / packing / covering constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 9741 of file cons_setppc.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_ERROR, SCIP_OKAY, SCIP_Real, SCIP_SETPPCTYPE_COVERING, SCIP_SETPPCTYPE_PACKING, SCIP_SETPPCTYPE_PARTITIONING, SCIPABORT, SCIPaddVarsToRowSameCoef(), SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconshdlrGetName(), SCIPconsIsLocal(), SCIPconsIsModifiable(), SCIPconsIsRemovable(), SCIPcreateEmptyRowCons(), SCIPerrorMessage, and SCIPinfinity().

Referenced by SCIPconsCreateRow().

SCIPgetNFixedonesSetppc()

int SCIPgetNFixedonesSetppc	(	SCIP *	scip,
		SCIP_CONS *	cons )

returns current number of variables fixed to one in the constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 9792 of file cons_setppc.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by addFixedVarsConss(), doPricing(), and initPricing().

SCIPgetNFixedzerosSetppc()

int SCIPgetNFixedzerosSetppc	(	SCIP *	scip,
		SCIP_CONS *	cons )

returns current number of variables fixed to zero in the constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 9816 of file cons_setppc.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

SCIPcleanupConssSetppc()

SCIP_RETCODE SCIPcleanupConssSetppc	(	SCIP *	scip,
		SCIP_Bool	onlychecked,
		SCIP_Bool *	infeasible,
		int *	naddconss,
		int *	ndelconss,
		int *	nchgcoefs,
		int *	nfixedvars )

cleans up (multi-)aggregations and fixings from setppc constraints

Parameters

scip	SCIP data structure
onlychecked	should only checked constraints be cleaned up?
infeasible	pointer to return whether problem was detected to be infeasible
naddconss	pointer to count number of added (linear) constraints
ndelconss	pointer to count number of deleted (setppc) constraints
nchgcoefs	pointer to count number of changed coefficients
nfixedvars	pointer to count number of fixed variables

Definition at line 9839 of file cons_setppc.c.

References applyFixings(), assert(), CONSHDLR_NAME, FALSE, i, mergeMultiples(), NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIPconshdlrGetCheckConss(), SCIPconshdlrGetConss(), SCIPconshdlrGetNActiveConss(), SCIPconshdlrGetNCheckConss(), SCIPconsIsDeleted(), and SCIPfindConshdlr().

Referenced by SCIPmatrixCreate().

SCIPcreateConsSOS1()

SCIP_RETCODE SCIPcreateConsSOS1	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_Real *	weights,
		SCIP_Bool	initial,
		SCIP_Bool	separate,
		SCIP_Bool	enforce,
		SCIP_Bool	check,
		SCIP_Bool	propagate,
		SCIP_Bool	local,
		SCIP_Bool	dynamic,
		SCIP_Bool	removable,
		SCIP_Bool	stickingatnode )

creates and captures an SOS1 constraint

We set the constraint to not be modifable. If the weights are non NULL, the variables are ordered according to these weights (in ascending order).

Note

The constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons().

creates and captures a SOS1 constraint

We set the constraint to not be modifable. If the weights are non NULL, the variables are ordered according to these weights (in ascending order).

Note

The constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons().

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nvars	number of variables in the constraint
vars	array with variables of constraint entries
weights	weights determining the variable order, or NULL if natural order should be used
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 10579 of file cons_sos1.c.

References assert(), CONSHDLR_NAME, FALSE, handleNewVariableSOS1(), NULL, nvars, propagate, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIP_Real, SCIP_STAGE_TRANSFORMED, SCIPallocBlockMemory, SCIPconshdlrGetData(), SCIPconsIsTransformed(), SCIPcreateCons(), SCIPduplicateBlockMemoryArray, SCIPerrorMessage, SCIPfindConshdlr(), SCIPgetStage(), SCIPgetTransformedVar(), SCIPisFinite, SCIPmarkDoNotMultaggrVar(), SCIPsortRealPtr(), SCIPvarIsTransformed(), separate(), and vars.

Referenced by addBranchingComplementaritiesSOS1(), extensionOperatorSOS1(), performImplicationGraphAnalysis(), readSOS(), readSos(), readSOScons(), SCIP_DECL_CONSCOPY(), SCIP_DECL_CONSPARSE(), and SCIPcreateConsBasicSOS1().

SCIPcreateConsBasicSOS1()

SCIP_RETCODE SCIPcreateConsBasicSOS1	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_Real *	weights )

creates and captures an SOS1 constraint in its most basic variant, i. e., with all constraint flags set to their default values, which can be set afterwards using SCIPsetConsFLAGNAME() in scip.h

See also

SCIPcreateConsSOS1() for the default constraint flag configuration

Warning

Do NOT set the constraint to be modifiable manually, because this might lead to wrong results as the variable array will not be re-sorted

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

creates and captures a SOS1 constraint with all constraint flags set to their default values.

Warning

Do NOT set the constraint to be modifiable manually, because this might lead to wrong results as the variable array will not be re-sorted

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nvars	number of variables in the constraint
vars	array with variables of constraint entries
weights	weights determining the variable order, or NULL if natural order should be used

Definition at line 10709 of file cons_sos1.c.

References FALSE, nvars, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPcreateConsSOS1(), TRUE, and vars.

Referenced by createKKTComplementarityBinary(), createKKTComplementarityBounds(), createKKTComplementarityLinear(), and AMPLProblemHandler::EndInput().

SCIPaddVarSOS1()

SCIP_RETCODE SCIPaddVarSOS1	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var,
		SCIP_Real	weight )

adds variable to SOS1 constraint, the position is determined by the given weight

Parameters

scip	SCIP data structure
cons	constraint
var	variable to add to the constraint
weight	weight determining position of variable

Definition at line 10725 of file cons_sos1.c.

References addVarSOS1(), assert(), CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_Real, SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconshdlrGetData(), SCIPconshdlrGetName(), SCIPdebugMsg, SCIPerrorMessage, SCIPisFinite, SCIPvarGetName(), and var.

Referenced by createKKTComplementarityBinary(), createKKTComplementarityBounds(), createKKTComplementarityLinear(), readSOS(), readSos(), readSOScons(), and SCIP_DECL_CONSPARSE().

SCIPappendVarSOS1()

SCIP_RETCODE SCIPappendVarSOS1	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var )

appends variable to SOS1 constraint

Parameters

scip	SCIP data structure
cons	constraint
var	variable to add to the constraint

Definition at line 10761 of file cons_sos1.c.

References appendVarSOS1(), assert(), CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconshdlrGetData(), SCIPconshdlrGetName(), SCIPdebugMsg, SCIPerrorMessage, SCIPvarGetName(), and var.

SCIPgetNVarsSOS1()

int SCIPgetNVarsSOS1	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets number of variables in SOS1 constraint

Parameters

scip	SCIP data structure
cons	constraint

Definition at line 10794 of file cons_sos1.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by SCIPwriteGms(), SCIPwriteLp(), and SCIPwriteMps().

SCIPgetVarsSOS1()

SCIP_VAR ** SCIPgetVarsSOS1	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets array of variables in SOS1 constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 10819 of file cons_sos1.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by SCIP_DECL_CONSGETPERMSYMGRAPH(), SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH(), SCIPwriteGms(), SCIPwriteLp(), and SCIPwriteMps().

SCIPgetWeightsSOS1()

SCIP_Real * SCIPgetWeightsSOS1	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets array of weights in SOS1 constraint (or NULL if not existent)

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 10844 of file cons_sos1.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_Real, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by SCIPgetConsVals(), SCIPwriteLp(), and SCIPwriteMps().

SCIPgetConflictgraphSOS1()

SCIP_DIGRAPH * SCIPgetConflictgraphSOS1

(

SCIP_CONSHDLR *

conshdlr

)

gets conflict graph of SOS1 constraints (or NULL if not existent)

Note

The conflict graph is globally valid; local changes are not taken into account.

Parameters

conshdlr

SOS1 constraint handler

Definition at line 10872 of file cons_sos1.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconshdlrGetData(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by getDiveBdChgsSOS1conflictgraph(), makeSOS1conflictgraphFeasible(), SCIP_DECL_SEPAEXECLP(), and sepaBoundInequalitiesFromGraph().

SCIPgetNSOS1Vars()

int SCIPgetNSOS1Vars

(

SCIP_CONSHDLR *

conshdlr

)

gets number of problem variables that are part of the SOS1 conflict graph

Parameters

conshdlr

SOS1 constraint handler

Definition at line 10894 of file cons_sos1.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconshdlrGetData(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by getDiveBdChgsSOS1conflictgraph(), makeSOS1conflictgraphFeasible(), SCIP_DECL_SEPAEXECLP(), SCIPperformGenericDivingAlgorithm(), and sepaBoundInequalitiesFromGraph().

SCIPvarIsSOS1()

SCIP_Bool SCIPvarIsSOS1	(	SCIP_CONSHDLR *	conshdlr,
		SCIP_VAR *	var )

returns whether variable is part of the SOS1 conflict graph

Parameters

conshdlr	SOS1 constraint handler
var	variable

Definition at line 10916 of file cons_sos1.c.

References assert(), CONSHDLR_NAME, FALSE, NULL, SCIP_Bool, SCIPABORT, SCIPconshdlrGetData(), SCIPconshdlrGetName(), SCIPerrorMessage, var, and varIsSOS1().

SCIPvarGetNodeSOS1()

int SCIPvarGetNodeSOS1	(	SCIP_CONSHDLR *	conshdlr,
		SCIP_VAR *	var )

returns node of variable in the conflict graph or -1 if variable is not part of the SOS1 conflict graph

Parameters

conshdlr	SOS1 constraint handler
var	variable

Definition at line 10940 of file cons_sos1.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconshdlrGetData(), SCIPconshdlrGetName(), SCIPerrorMessage, var, and varGetNodeSOS1().

Referenced by markNeighborsMWISHeuristic().

SCIPnodeGetVarSOS1()

SCIP_VAR * SCIPnodeGetVarSOS1	(	SCIP_DIGRAPH *	conflictgraph,
		int	node )

returns variable that belongs to a given node from the conflict graph

Parameters

conflictgraph	conflict graph
node	node from the conflict graph

Definition at line 10971 of file cons_sos1.c.

References assert(), nodedata, NULL, SCIPABORT, SCIPdigraphGetNNodes(), SCIPdigraphGetNodeData(), and SCIPerrorMessage.

Referenced by addBranchingComplementaritiesSOS1(), enforceConflictgraph(), extensionOperatorSOS1(), getBranchingDecisionStrongbranchSOS1(), getBranchingPrioritiesSOS1(), getBranchingVerticesSOS1(), getDiveBdChgsSOS1conflictgraph(), getVectorOfWeights(), initImplGraphSOS1(), initTCliquegraph(), isViolatedSOS1(), makeSOS1conflictgraphFeasible(), markNeighborsMWISHeuristic(), nodeGetSolvalBinaryBigMSOS1(), performImplicationGraphAnalysis(), performStrongbranchSOS1(), presolRoundVarsSOS1(), propVariableNonzero(), SCIP_DECL_CONSRESPROP(), SCIP_DECL_SEPAEXECLP(), TCLIQUE_NEWSOL(), tightenVarsBoundsSOS1(), and updateWeightsTCliquegraph().

SCIPmakeSOS1sFeasible()

SCIP_RETCODE SCIPmakeSOS1sFeasible	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_SOL *	sol,
		SCIP_Bool *	changed,
		SCIP_Bool *	success )

based on solution values of the variables, fixes variables to zero to turn all SOS1 constraints feasible

Parameters

scip	SCIP pointer
conshdlr	SOS1 constraint handler
sol	solution
changed	pointer to store whether the solution has been changed
success	pointer to store whether SOS1 constraints have been turned feasible and solution was good enough

Definition at line 10996 of file cons_sos1.c.

References assert(), CONSHDLR_NAME, FALSE, makeSOS1conflictgraphFeasible(), makeSOS1constraintsFeasible(), NULL, SCIP_Bool, SCIP_CALL, SCIP_OBJSENSE_MAXIMIZE, SCIP_OKAY, SCIP_PARAMETERWRONGVAL, SCIP_Real, SCIPconshdlrGetData(), SCIPconshdlrGetName(), SCIPconshdlrGetNConss(), SCIPerrorMessage, SCIPgetObjsense(), SCIPgetSolOrigObj(), SCIPgetUpperbound(), SCIPisLT(), sol, and TRUE.

Referenced by SCIPperformGenericDivingAlgorithm().

SCIPcreateConsSOS2()

SCIP_RETCODE SCIPcreateConsSOS2	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_Real *	weights,
		SCIP_Bool	initial,
		SCIP_Bool	separate,
		SCIP_Bool	enforce,
		SCIP_Bool	check,
		SCIP_Bool	propagate,
		SCIP_Bool	local,
		SCIP_Bool	dynamic,
		SCIP_Bool	removable,
		SCIP_Bool	stickingatnode )

creates and captures an SOS2 constraint

We set the constraint to not be modifable. If the weights are non NULL, the variables are ordered according to these weights (in ascending order).

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

creates and captures a SOS2 constraint

We set the constraint to not be modifable. If the weights are non NULL, the variables are ordered according to these weights (in ascending order).

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nvars	number of variables in the constraint
vars	array with variables of constraint entries
weights	weights determining the variable order, or NULL if natural order should be used
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 2578 of file cons_sos2.c.

References assert(), CONSHDLR_NAME, FALSE, NULL, nvars, propagate, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIP_Real, SCIPallocBlockMemory, SCIPcreateCons(), SCIPduplicateBlockMemoryArray, SCIPerrorMessage, SCIPfindConshdlr(), SCIPisFinite, SCIPsortRealPtr(), separate(), and vars.

Referenced by readSOS(), readSos(), readSOScons(), SCIP_DECL_CONSCOPY(), SCIP_DECL_CONSPARSE(), and SCIPcreateConsBasicSOS2().

SCIPcreateConsBasicSOS2()

SCIP_RETCODE SCIPcreateConsBasicSOS2	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nvars,
		SCIP_VAR **	vars,
		SCIP_Real *	weights )

creates and captures a SOS2 constraint with all constraint flags set to their default values.

Warning

Do NOT set the constraint to be modifiable manually, because this might lead to wrong results as the variable array will not be re-sorted

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
nvars	number of variables in the constraint
vars	array with variables of constraint entries
weights	weights determining the variable order, or NULL if natural order should be used

Definition at line 2671 of file cons_sos2.c.

References FALSE, nvars, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPcreateConsSOS2(), TRUE, and vars.

Referenced by AMPLProblemHandler::EndInput().

SCIPaddVarSOS2()

SCIP_RETCODE SCIPaddVarSOS2	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var,
		SCIP_Real	weight )

adds variable to SOS2 constraint, the position is determined by the given weight

Parameters

scip	SCIP data structure
cons	constraint
var	variable to add to the constraint
weight	weight determining position of variable

Definition at line 2687 of file cons_sos2.c.

References addVarSOS2(), assert(), CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_Real, SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconshdlrGetName(), SCIPdebugMsg, SCIPerrorMessage, SCIPisFinite, SCIPvarGetName(), and var.

Referenced by readSOS(), readSos(), readSOScons(), and SCIP_DECL_CONSPARSE().

SCIPappendVarSOS2()

SCIP_RETCODE SCIPappendVarSOS2	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var )

appends variable to SOS2 constraint

Parameters

scip	SCIP data structure
cons	constraint
var	variable to add to the constraint

Definition at line 2715 of file cons_sos2.c.

References appendVarSOS2(), assert(), CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconshdlrGetName(), SCIPdebugMsg, SCIPerrorMessage, SCIPvarGetName(), and var.

SCIPgetNVarsSOS2()

int SCIPgetNVarsSOS2	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets number of variables in SOS2 constraint

Parameters

scip	SCIP data structure
cons	constraint

Definition at line 2740 of file cons_sos2.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by SCIPwriteGms(), SCIPwriteLp(), and SCIPwriteMps().

SCIPgetVarsSOS2()

SCIP_VAR ** SCIPgetVarsSOS2	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets array of variables in SOS2 constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 2765 of file cons_sos2.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by SCIP_DECL_CONSGETPERMSYMGRAPH(), SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH(), SCIPwriteGms(), SCIPwriteLp(), and SCIPwriteMps().

SCIPgetWeightsSOS2()

SCIP_Real * SCIPgetWeightsSOS2	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets array of weights in SOS2 constraint (or NULL if not existent)

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 2790 of file cons_sos2.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_Real, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by SCIPgetConsVals(), SCIPwriteLp(), and SCIPwriteMps().

SCIPcreateConsSuperindicator()

SCIP_RETCODE SCIPcreateConsSuperindicator	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_VAR *	binvar,
		SCIP_CONS *	slackcons,
		SCIP_Bool	initial,
		SCIP_Bool	separate,
		SCIP_Bool	enforce,
		SCIP_Bool	check,
		SCIP_Bool	propagate,
		SCIP_Bool	local,
		SCIP_Bool	dynamic,
		SCIP_Bool	removable,
		SCIP_Bool	stickingatnode )

creates and captures a superindicator constraint

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
binvar	pointer to the indicator constraint
slackcons	constraint corresponding to the handled constraint
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 2143 of file cons_superindicator.c.

References assert(), consdataCreateSuperindicator(), CONSHDLR_NAME, FALSE, NULL, propagate, SCIP_Bool, SCIP_CALL, SCIP_INVALIDCALL, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconshdlrGetData(), SCIPconshdlrGetName(), SCIPcreateCons(), SCIPerrorMessage, SCIPfindConshdlr(), SCIPwarningMessage(), and separate().

Referenced by SCIP_DECL_CONSCOPY(), SCIP_DECL_CONSPARSE(), SCIPcreateConsBasicSuperindicator(), and SCIPtransformMinUC().

SCIPcreateConsBasicSuperindicator()

SCIP_RETCODE SCIPcreateConsBasicSuperindicator	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_VAR *	binvar,
		SCIP_CONS *	slackcons )

creates and captures a superindicator constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsSuperindicator(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h

See also

SCIPcreateConsSuperindicator() for information about the basic constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
binvar	pointer to the indicator constraint
slackcons	constraint corresponding to the handled constraint

Definition at line 2250 of file cons_superindicator.c.

References assert(), FALSE, NULL, SCIP_CALL, SCIP_OKAY, SCIPcreateConsSuperindicator(), and TRUE.

SCIPgetBinaryVarSuperindicator()

SCIP_VAR * SCIPgetBinaryVarSuperindicator

(

SCIP_CONS *

cons

)

gets binary variable corresponding to the superindicator constraint

gets binary variable corresponding to the general indicator constraint

Parameters

cons	superindicator constraint

Definition at line 2272 of file cons_superindicator.c.

References assert(), CONSHDLR_NAME, NULL, SCIPconsGetData(), SCIPconsGetHdlr(), and SCIPconshdlrGetName().

SCIPgetSlackConsSuperindicator()

SCIP_CONS * SCIPgetSlackConsSuperindicator

(

SCIP_CONS *

cons

)

gets the slack constraint corresponding to the superindicator constraint

gets the slack constraint corresponding to the general indicator constraint

Parameters

cons	superindicator constraint

Definition at line 2284 of file cons_superindicator.c.

References assert(), CONSHDLR_NAME, NULL, SCIPconsGetData(), SCIPconsGetHdlr(), and SCIPconshdlrGetName().

SCIP_DECL_DIALOGEXEC() [4/4]

SCIP_DECL_DIALOGEXEC

(

SCIPdialogExecChangeMinUC

)

dialog execution method for the SCIPtransformMinUC() command

dialog execution method for the SCIPtransformMinUC() method

Definition at line 2439 of file cons_superindicator.c.

References FALSE, NULL, SCIP_Bool, SCIP_CALL, SCIP_INVALIDCALL, SCIP_OKAY, SCIP_STAGE_EXITPRESOLVE, SCIP_STAGE_EXITSOLVE, SCIP_STAGE_FREE, SCIP_STAGE_FREETRANS, SCIP_STAGE_INIT, SCIP_STAGE_INITPRESOLVE, SCIP_STAGE_INITSOLVE, SCIP_STAGE_PRESOLVED, SCIP_STAGE_PRESOLVING, SCIP_STAGE_PROBLEM, SCIP_STAGE_SOLVED, SCIP_STAGE_SOLVING, SCIP_STAGE_TRANSFORMED, SCIP_STAGE_TRANSFORMING, SCIPdialoghdlrAddHistory(), SCIPdialoghdlrGetRoot(), SCIPdialogMessage(), SCIPerrorMessage, SCIPgetNBinImplVars(), SCIPgetNBinVars(), SCIPgetNConss(), SCIPgetNContImplVars(), SCIPgetNContVars(), SCIPgetNIntImplVars(), SCIPgetNIntVars(), SCIPgetNVars(), SCIPgetStage(), and SCIPtransformMinUC().

SCIPcreateSymbreakCons()

SCIP_RETCODE SCIPcreateSymbreakCons	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int *	perm,
		SCIP_VAR **	vars,
		int	nvars,
		SCIP_Bool	ismodelcons,
		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 )

creates a symmetry breaking constraint

Depending on the given permutation, either an orbisack or symresack constraint is created.

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
perm	permutation
vars	variables
nvars	number of variables in vars array
ismodelcons	whether the added constraint is a model constraint
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 1731 of file cons_symresack.c.

References assert(), FALSE, NULL, nvars, orbisackUpgrade(), propagate, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIPcreateConsSymresack(), separate(), and vars.

Referenced by addSymresackConss(), and detectAndHandleSubgroups().

SCIPcreateConsSymresack()

SCIP_RETCODE SCIPcreateConsSymresack	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int *	perm,
		SCIP_VAR **	vars,
		int	nvars,
		SCIP_Bool	ismodelcons,
		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 )

creates and captures a symresack constraint

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

creates and captures a symresack constraint

In a presolving step, we check whether the permutation acts only on binary points. Otherwise, we eliminate the non-binary variables from the permutation.

Note

The constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons().

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
perm	permutation
vars	variables
nvars	number of variables in vars array
ismodelcons	whether the symresack is a model constraint
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 3210 of file cons_symresack.c.

References assert(), consdataCreate(), CONSHDLR_NAME, NULL, nvars, propagate, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIPcreateCons(), SCIPerrorMessage, SCIPfindConshdlr(), separate(), and vars.

Referenced by SCIP_DECL_CONSCOPY(), SCIPcreateConsBasicSymresack(), and SCIPcreateSymbreakCons().

SCIPcreateConsBasicSymresack()

SCIP_RETCODE SCIPcreateConsBasicSymresack	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int *	perm,
		SCIP_VAR **	vars,
		int	nvars,
		SCIP_Bool	ismodelcons )

creates and captures a symresack constraint in its most basic variant, i.e., with all constraint flags set to their default values, which can be set afterwards using SCIPsetConsFLAGNAME() in scip.h

See also

SCIPcreateConsSymresack() for the default constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

creates and captures a symresack constraint in its most basic variant, i.e., with all constraint flags set to their default values

In a presolving step, we remove all fixed points and cycles that act on non-binary variables of the permutation

Note

The constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons().

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
perm	permutation
vars	variables
nvars	number of variables in vars array
ismodelcons	whether the symresack is a model constraint

Definition at line 3275 of file cons_symresack.c.

References FALSE, nvars, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIPcreateConsSymresack(), TRUE, and vars.

Referenced by SCIP_DECL_CONSPARSE().

SCIPcreateConsVarbound()

SCIP_RETCODE SCIPcreateConsVarbound	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_VAR *	var,
		SCIP_VAR *	vbdvar,
		SCIP_Real	vbdcoef,
		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 )

creates and captures a variable bound constraint: lhs <= x + c*y <= rhs

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
var	variable x that has variable bound
vbdvar	binary, integer or implicit integer bounding variable y
vbdcoef	coefficient c of bounding variable y
lhs	left hand side of variable bound inequality
rhs	right hand side of variable bound inequality
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 5785 of file cons_varbound.c.

References assert(), catchEvents(), consdataCreate(), CONSHDLR_NAME, NULL, propagate, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIP_Real, SCIPconshdlrGetData(), SCIPcreateCons(), SCIPerrorMessage, SCIPfindConshdlr(), SCIPisFinite, SCIPisTransformed(), separate(), and var.

Referenced by createPrecedenceCons(), createVarUbs(), SCIP_DECL_CONSINITLP(), SCIP_DECL_CONSPARSE(), SCIP_DECL_LINCONSUPGD(), SCIPcreateConsBasicVarbound(), and SCIPcreateSchedulingProblem().

SCIPcreateConsBasicVarbound()

SCIP_RETCODE SCIPcreateConsBasicVarbound	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_VAR *	var,
		SCIP_VAR *	vbdvar,
		SCIP_Real	vbdcoef,
		SCIP_Real	lhs,
		SCIP_Real	rhs )

creates and captures a varbound constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsVarbound(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h

See also

SCIPcreateConsVarbound() for information about the basic constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

creates and captures a variable bound constraint: lhs <= x + c*y <= rhs with all constraint flags set to their default values

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
var	variable x that has variable bound
vbdvar	binary, integer or implicit integer bounding variable y
vbdcoef	coefficient c of bounding variable y
lhs	left hand side of variable bound inequality
rhs	right hand side of variable bound inequality

Definition at line 5860 of file cons_varbound.c.

References FALSE, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPcreateConsVarbound(), TRUE, and var.

Referenced by addBranchingDecisionConss(), applyRepair(), createVarboundCons(), getBinaryProductExprDo(), and reformulateFactorizedBinaryQuadratic().

SCIPgetLhsVarbound()

SCIP_Real SCIPgetLhsVarbound	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets left hand side of variable bound constraint lhs <= x + c*y <= rhs

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 5878 of file cons_varbound.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_INVALID, SCIP_Real, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by addSymmetryInformation(), addVarboundConstraints(), checkVarbound(), createAltLP(), createAltLP(), matrixCreate(), presolveAddKKTVarboundConss(), printRangeSection(), SCIP_DECL_CONSCOPY(), SCIPconsGetLhs(), SCIPmatrixCreate(), SCIPwriteGms(), SCIPwriteLp(), SCIPwriteMps(), SCIPwritePip(), writeFzn(), and writeOpbConstraints().

SCIPgetRhsVarbound()

SCIP_Real SCIPgetRhsVarbound	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets right hand side of variable bound constraint lhs <= x + c*y <= rhs

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 5901 of file cons_varbound.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_INVALID, SCIP_Real, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by addSymmetryInformation(), addVarboundConstraints(), checkVarbound(), createAltLP(), createAltLP(), matrixCreate(), presolveAddKKTVarboundConss(), printRangeSection(), SCIP_DECL_CONSCOPY(), SCIPconsGetRhs(), SCIPmatrixCreate(), SCIPwriteGms(), SCIPwriteLp(), SCIPwriteMps(), SCIPwritePip(), writeFzn(), and writeOpbConstraints().

SCIPgetVarVarbound()

SCIP_VAR * SCIPgetVarVarbound	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets bounded variable x of variable bound constraint lhs <= x + c*y <= rhs

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 5924 of file cons_varbound.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by addSymmetryInformation(), addVarboundConstraints(), checkVarbound(), createAltLP(), createAltLP(), SCIPNLFeeder::FeedLinearConExpr(), matrixCreate(), presolveAddKKTVarboundConss(), SCIP_DECL_CONSCOPY(), SCIPmatrixCreate(), SCIPwriteCcg(), SCIPwriteGms(), SCIPwriteLp(), SCIPwriteMps(), SCIPwritePbm(), SCIPwritePip(), SCIPwritePpm(), writeFzn(), and writeOpbConstraints().

SCIPgetVbdvarVarbound()

SCIP_VAR * SCIPgetVbdvarVarbound	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets bounding variable y of variable bound constraint lhs <= x + c*y <= rhs

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 5947 of file cons_varbound.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by addSymmetryInformation(), addVarboundConstraints(), checkVarbound(), createAltLP(), createAltLP(), createMaps(), SCIPNLFeeder::FeedLinearConExpr(), matrixCreate(), presolveAddKKTVarboundConss(), SCIP_DECL_CONSCOPY(), SCIP_DECL_DIVESETGETSCORE(), SCIPmatrixCreate(), SCIPwriteCcg(), SCIPwriteGms(), SCIPwriteLp(), SCIPwriteMps(), SCIPwritePbm(), SCIPwritePip(), SCIPwritePpm(), writeFzn(), and writeOpbConstraints().

SCIPgetVbdcoefVarbound()

SCIP_Real SCIPgetVbdcoefVarbound	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets bound coefficient c of variable bound constraint lhs <= x + c*y <= rhs

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 5970 of file cons_varbound.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_INVALID, SCIP_Real, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by addSymmetryInformation(), addVarboundConstraints(), checkVarbound(), createAltLP(), createAltLP(), SCIPNLFeeder::FeedLinearConExpr(), matrixCreate(), presolveAddKKTVarboundConss(), SCIP_DECL_CONSCOPY(), SCIPgetConsVals(), SCIPmatrixCreate(), SCIPwriteCcg(), SCIPwriteGms(), SCIPwriteLp(), SCIPwriteMps(), SCIPwritePbm(), SCIPwritePip(), SCIPwritePpm(), writeFzn(), and writeOpbConstraints().

SCIPgetDualsolVarbound()

SCIP_Real SCIPgetDualsolVarbound	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets the dual solution of the variable bound constraint in the current LP

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 5993 of file cons_varbound.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_INVALID, SCIP_Real, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPerrorMessage, and SCIProwGetDualsol().

Referenced by SCIPconsGetDualsol().

SCIPgetDualfarkasVarbound()

SCIP_Real SCIPgetDualfarkasVarbound	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets the dual Farkas value of the variable bound constraint in the current infeasible LP

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 6019 of file cons_varbound.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_INVALID, SCIP_Real, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPerrorMessage, and SCIProwGetDualfarkas().

Referenced by SCIPconsGetDualfarkas().

SCIPgetRowVarbound()

SCIP_ROW * SCIPgetRowVarbound	(	SCIP *	scip,
		SCIP_CONS *	cons )

returns the linear relaxation of the given variable bound constraint; may return NULL if no LP row was yet created; the user must not modify the row!

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 6047 of file cons_varbound.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by SCIPconsCreateRow(), and SCIPconsGetRow().

SCIPcreateRowVarbound()

SCIP_RETCODE SCIPcreateRowVarbound	(	SCIP *	scip,
		SCIP_CONS *	cons )

creates and returns the row of the given varbound constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 6070 of file cons_varbound.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_ERROR, SCIP_OKAY, SCIPABORT, SCIPaddVarToRow(), SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconshdlrGetName(), SCIPconsIsLocal(), SCIPconsIsModifiable(), SCIPconsIsRemovable(), SCIPcreateEmptyRowCons(), and SCIPerrorMessage.

Referenced by SCIPconsCreateRow().

SCIPcleanupConssVarbound()

SCIP_RETCODE SCIPcleanupConssVarbound	(	SCIP *	scip,
		SCIP_Bool	onlychecked,
		SCIP_Bool *	infeasible,
		int *	naddconss,
		int *	ndelconss,
		int *	nchgbds )

cleans up (multi-)aggregations and fixings from varbound constraints

Parameters

scip	SCIP data structure
onlychecked	should only checked constraints be cleaned up?
infeasible	pointer to return whether the problem was detected to be infeasible
naddconss	pointer to count number of added (linear) constraints
ndelconss	pointer to count number of deleted (varbound) constraints
nchgbds	pointer to count number of bound changes

Definition at line 6099 of file cons_varbound.c.

References applyFixings(), assert(), CONSHDLR_NAME, FALSE, i, NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIPconshdlrGetCheckConss(), SCIPconshdlrGetConss(), SCIPconshdlrGetData(), SCIPconshdlrGetNActiveConss(), SCIPconshdlrGetNCheckConss(), and SCIPfindConshdlr().

Referenced by SCIPmatrixCreate().

SCIPcreateConsXor()

SCIP_RETCODE SCIPcreateConsXor	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_Bool	rhs,
		int	nvars,
		SCIP_VAR **	vars,
		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 )

creates and captures an xor constraint

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

creates and captures a xor constraint x_0 xor ... xor x_{k-1} = rhs

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
rhs	right hand side of the constraint
nvars	number of operator variables in the constraint
vars	array with operator variables of constraint
initial	should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separate	should the constraint be separated during LP processing? Usually set to TRUE.
enforce	should the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
check	should the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagate	should the constraint be propagated during node processing? Usually set to TRUE.
local	is constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiable	is constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamic	is constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removable	should the relaxation be removed from the LP due to aging or cleanup? Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'.
stickingatnode	should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? Usually set to FALSE. Set to TRUE to for constraints that represent node data.

Definition at line 6014 of file cons_xor.c.

References assert(), consdataCreate(), CONSHDLR_NAME, i, NULL, nvars, propagate, SCIP_Bool, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIPcreateCons(), SCIPerrorMessage, SCIPfindConshdlr(), SCIPvarGetName(), SCIPvarIsBinary(), separate(), and vars.

Referenced by CREATE_CONSTRAINT(), SCIP_DECL_CONSPARSE(), SCIPcreateConsBasicXor(), and tryUpgradingXor().

SCIPcreateConsBasicXor()

SCIP_RETCODE SCIPcreateConsBasicXor	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		SCIP_Bool	rhs,
		int	nvars,
		SCIP_VAR **	vars )

creates and captures an xor constraint in its most basic version, i. e., all constraint flags are set to their basic value as explained for the method SCIPcreateConsXor(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h

See also

SCIPcreateConsXor() for information about the basic constraint flag configuration

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

creates and captures a xor constraint x_0 xor ... xor x_{k-1} = rhs with all constraint flags set to their default values

Note

the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()

Parameters

scip	SCIP data structure
cons	pointer to hold the created constraint
name	name of constraint
rhs	right hand side of the constraint
nvars	number of operator variables in the constraint
vars	array with operator variables of constraint

Definition at line 6084 of file cons_xor.c.

References FALSE, nvars, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIPcreateConsXor(), TRUE, and vars.

Referenced by createMIP(), AMPLProblemHandler::OnBinaryLogical(), and AMPLProblemHandler::OnRelational().

SCIPgetNVarsXor()

int SCIPgetNVarsXor	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets number of variables in xor constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 6100 of file cons_xor.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by matrixCreate().

SCIPgetVarsXor()

SCIP_VAR ** SCIPgetVarsXor	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets array of variables in xor constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 6123 of file cons_xor.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by matrixCreate().

SCIPgetIntVarXor()

SCIP_VAR * SCIPgetIntVarXor	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets integer variable in xor constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 6146 of file cons_xor.c.

References assert(), CONSHDLR_NAME, NULL, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by matrixCreate().

SCIPgetRhsXor()

SCIP_Bool SCIPgetRhsXor	(	SCIP *	scip,
		SCIP_CONS *	cons )

gets the right hand side of the xor constraint

Parameters

scip	SCIP data structure
cons	constraint data

Definition at line 6169 of file cons_xor.c.

References assert(), CONSHDLR_NAME, NULL, SCIP_Bool, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by addSymmetryInformation(), matrixCreate(), and SCIP_DECL_CONSCOPY().