Detailed Description

constraint handler for quadratic constraints $\textrm{lhs} \leq \sum_{i,j=1}^n a_{i,j} x_i x_j + \sum_{i=1}^n b_i x_i \leq \textrm{rhs}$

Author: Stefan Vigerske; Benjamin Mueller; Felipe Serrano

Definition in file cons_quadratic.c.

#include <assert.h>
#include <string.h>
#include <ctype.h>
#include <math.h>
#include "scip/cons_nonlinear.h"
#include "scip/cons_quadratic.h"
#include "scip/cons_linear.h"
#include "scip/cons_and.h"
#include "scip/cons_varbound.h"
#include "scip/intervalarith.h"
#include "scip/heur_subnlp.h"
#include "scip/heur_trysol.h"
#include "scip/debug.h"
#include "nlpi/nlpi.h"
#include "nlpi/nlpi_ipopt.h"

Go to the source code of this file.

Macros
#define	CONSHDLR_NAME "quadratic"

#define	CONSHDLR_DESC "quadratic constraints of the form lhs <= b' x + x' A x <= rhs"

#define	CONSHDLR_SEPAPRIORITY 10

#define	CONSHDLR_ENFOPRIORITY -50

#define	CONSHDLR_CHECKPRIORITY -4000000

#define	CONSHDLR_SEPAFREQ 1

#define	CONSHDLR_PROPFREQ 1

#define	CONSHDLR_EAGERFREQ 100

#define	CONSHDLR_MAXPREROUNDS -1

#define	CONSHDLR_DELAYSEPA FALSE

#define	CONSHDLR_DELAYPROP FALSE

#define	CONSHDLR_NEEDSCONS TRUE

#define	CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP

#define	CONSHDLR_PRESOLTIMING SCIP_PRESOLTIMING_ALWAYS

#define	MAXDNOM 10000LL

#define	NONLINCONSUPGD_PRIORITY 40000

#define	INITLPMAXVARVAL 1000.0

#define	PROPBILINNEW

#define	INTERIOR_EPS 1e-1

#define	GAUGESCALE 0.99999

#define	infty2infty(infty1, infty2, val) ((val) >= (infty1) ? (infty2) : (val))

Typedefs
typedef struct SCIP_QuadConsUpgrade	SCIP_QUADCONSUPGRADE

Functions
static SCIP_Bool	conshdlrdataHasUpgrade (SCIP scip, SCIP_CONSHDLRDATA conshdlrdata, SCIP_DECL_QUADCONSUPGD((quadconsupgd)), const char conshdlrname)

static SCIP_RETCODE	catchLinearVarEvents (SCIP scip, SCIP_EVENTHDLR eventhdlr, SCIP_CONS *cons, int linvarpos)

static SCIP_RETCODE	dropLinearVarEvents (SCIP scip, SCIP_EVENTHDLR eventhdlr, SCIP_CONS *cons, int linvarpos)

static SCIP_RETCODE	catchQuadVarEvents (SCIP scip, SCIP_EVENTHDLR eventhdlr, SCIP_CONS *cons, int quadvarpos)

static SCIP_RETCODE	dropQuadVarEvents (SCIP scip, SCIP_EVENTHDLR eventhdlr, SCIP_CONS *cons, int quadvarpos)

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

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

static SCIP_RETCODE	lockLinearVariable (SCIP scip, SCIP_CONS cons, SCIP_VAR *var, SCIP_Real coef)

static SCIP_RETCODE	unlockLinearVariable (SCIP scip, SCIP_CONS cons, SCIP_VAR *var, SCIP_Real coef)

static SCIP_RETCODE	lockQuadraticVariable (SCIP scip, SCIP_CONS cons, SCIP_VAR *var)

static SCIP_RETCODE	unlockQuadraticVariable (SCIP scip, SCIP_CONS cons, SCIP_VAR *var)

static void	consdataUpdateLinearActivity (SCIP scip, SCIP_CONSDATA consdata, SCIP_Real intervalinfty)

static void	consdataUpdateLinearActivityLbChange (SCIP scip, SCIP_CONSDATA consdata, SCIP_Real coef, SCIP_Real oldbnd, SCIP_Real newbnd)

static void	consdataUpdateLinearActivityUbChange (SCIP scip, SCIP_CONSDATA consdata, SCIP_Real coef, SCIP_Real oldbnd, SCIP_Real newbnd)

static	SCIP_DECL_EVENTEXEC (processVarEvent)

static SCIP_RETCODE	consdataEnsureLinearVarsSize (SCIP scip, SCIP_CONSDATA consdata, int num)

static SCIP_RETCODE	consdataEnsureQuadVarTermsSize (SCIP scip, SCIP_CONSDATA consdata, int num)

static SCIP_RETCODE	consdataEnsureAdjBilinSize (SCIP scip, SCIP_QUADVARTERM quadvarterm, int num)

static SCIP_RETCODE	consdataEnsureBilinSize (SCIP scip, SCIP_CONSDATA consdata, int num)

static SCIP_RETCODE	consdataCreateEmpty (SCIP scip, SCIP_CONSDATA *consdata)

static SCIP_RETCODE	consdataCreate (SCIP scip, SCIP_CONSDATA consdata, SCIP_Real lhs, SCIP_Real rhs, int nlinvars, SCIP_VAR linvars, SCIP_Real lincoefs, int nquadvars, SCIP_QUADVARTERM quadvarterms, int nbilinterms, SCIP_BILINTERM bilinterms, SCIP_Bool capturevars)

static SCIP_RETCODE	consdataFree (SCIP scip, SCIP_CONSDATA *consdata)

static void	consdataSortLinearVars (SCIP_CONSDATA *consdata)

static	SCIP_DECL_SORTINDCOMP (quadVarTermComp)

static SCIP_RETCODE	consdataSortQuadVarTerms (SCIP scip, SCIP_CONSDATA consdata)

static SCIP_RETCODE	consdataFindQuadVarTerm (SCIP scip, SCIP_CONSDATA consdata, SCIP_VAR var, int pos)

static	SCIP_DECL_SORTINDCOMP (bilinTermComp)

static SCIP_Bool	consdataCheckBilinTermsSort (SCIP_CONSDATA *consdata)

static SCIP_RETCODE	consdataSortBilinTerms (SCIP scip, SCIP_CONSDATA consdata)

static void	consdataMoveLinearVar (SCIP_CONSDATA *consdata, int oldpos, int newpos)

static void	consdataMoveQuadVarTerm (SCIP_CONSDATA *consdata, int oldpos, int newpos)

static SCIP_RETCODE	addLinearCoef (SCIP scip, SCIP_CONS cons, SCIP_VAR *var, SCIP_Real coef)

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

static SCIP_RETCODE	chgLinearCoefPos (SCIP scip, SCIP_CONS cons, int pos, SCIP_Real newcoef)

static SCIP_RETCODE	addQuadVarTerm (SCIP scip, SCIP_CONS cons, SCIP_VAR *var, SCIP_Real lincoef, SCIP_Real sqrcoef)

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

static SCIP_RETCODE	replaceQuadVarTermPos (SCIP scip, SCIP_CONS cons, int pos, SCIP_VAR *var, SCIP_Real coef, SCIP_Real offset)

static SCIP_RETCODE	addBilinearTerm (SCIP scip, SCIP_CONS cons, int var1pos, int var2pos, SCIP_Real coef)

static SCIP_RETCODE	removeBilinearTermsPos (SCIP scip, SCIP_CONS cons, int nterms, int *termposs)

static SCIP_RETCODE	mergeAndCleanQuadVarTerms (SCIP scip, SCIP_CONS cons)

static SCIP_RETCODE	mergeAndCleanLinearVars (SCIP scip, SCIP_CONS cons)

static SCIP_RETCODE	mergeAndCleanBilinearTerms (SCIP scip, SCIP_CONS cons)

static SCIP_RETCODE	removeFixedVariables (SCIP scip, SCIP_CONS cons)

static SCIP_RETCODE	createNlRow (SCIP scip, SCIP_CONS cons)

static SCIP_RETCODE	presolveSolve (SCIP scip, SCIP_CONS cons, SCIP_RESULT result, SCIP_Bool redundant, int *naggrvars)

static SCIP_RETCODE	presolveTryAddAND (SCIP scip, SCIP_CONSHDLR conshdlr, SCIP_CONS cons, int naddconss)

static SCIP_RETCODE	getImpliedBounds (SCIP scip, SCIP_VAR x, SCIP_Bool xval, SCIP_VAR y, SCIP_INTERVAL resultant)

static SCIP_RETCODE	presolveTryAddLinearReform (SCIP scip, SCIP_CONSHDLR conshdlr, SCIP_CONS cons, int naddconss)

static SCIP_RETCODE	presolveUpgrade (SCIP scip, SCIP_CONSHDLR conshdlr, SCIP_CONS cons, SCIP_Bool upgraded, int nupgdconss, int naddconss, SCIP_PRESOLTIMING presoltiming)

static SCIP_RETCODE	presolveDisaggregateMarkComponent (SCIP scip, SCIP_CONSDATA consdata, int quadvaridx, SCIP_HASHMAP *var2component, int componentnr)

static SCIP_RETCODE	presolveDisaggregate (SCIP scip, SCIP_CONSHDLR conshdlr, SCIP_CONS cons, int naddconss)

static void	checkCurvatureEasy (SCIP scip, SCIP_CONS cons, SCIP_Bool *determined, SCIP_Bool checkmultivariate)

static SCIP_RETCODE	checkCurvature (SCIP scip, SCIP_CONS cons, SCIP_Bool checkmultivariate)

static SCIP_RETCODE	checkFactorable (SCIP scip, SCIP_CONS cons)

static SCIP_Real	getGradientMaxElement (SCIP scip, SCIP_CONS cons, SCIP_SOL *sol)

static SCIP_RETCODE	computeViolation (SCIP scip, SCIP_CONSHDLR conshdlr, SCIP_CONS cons, SCIP_SOL sol)

static SCIP_RETCODE	computeViolations (SCIP scip, SCIP_CONSHDLR conshdlr, SCIP_CONS *conss, int nconss, SCIP_SOL sol, SCIP_CONS **maxviolcon)

static void	generateCutFactorableDo (SCIP scip, SCIP_CONS cons, SCIP_Real ref, SCIP_Real multleft, SCIP_Real coefleft, SCIP_Real multright, SCIP_Real coefright, SCIP_Real rightminactivity, SCIP_Real rightmaxactivity, SCIP_Real rhs, SCIP_Real cutcoef, SCIP_Real cutrhs, SCIP_Bool islocal, SCIP_Bool success, char name)

static SCIP_RETCODE	generateCutFactorable (SCIP scip, SCIP_CONS cons, SCIP_SIDETYPE violside, SCIP_Real ref, SCIP_Real cutcoef, SCIP_Real cutlhs, SCIP_Real cutrhs, SCIP_Bool islocal, SCIP_Bool success, char *name)

static SCIP_Bool	generateCutLTIfindIntersection (SCIP scip, SCIP_Real x0, SCIP_Real y0_, SCIP_Real x1, SCIP_Real y1_, SCIP_Real wl, SCIP_Real wu, SCIP_Real xl, SCIP_Real yl, SCIP_Real xu, SCIP_Real *yu)

static SCIP_Bool	generateCutLTIgenMulCoeff (SCIP scip, SCIP_Real x1, SCIP_Real y1_, SCIP_Real x2, SCIP_Real y2, SCIP_Bool whichuse, SCIP_Real cx, SCIP_Real cy, SCIP_Real cw)

static void	generateCutLTIcomputeCoefs (SCIP scip, SCIP_Real xl, SCIP_Real xu, SCIP_Real x0, SCIP_Real yl, SCIP_Real yu, SCIP_Real y0_, SCIP_Real wl, SCIP_Real wu, SCIP_Real w0, SCIP_Real cx, SCIP_Real cy, SCIP_Real cw, SCIP_Real c0, SCIP_Bool success)

static SCIP_RETCODE	generateCutLTI (SCIP scip, SCIP_CONS cons, SCIP_SIDETYPE violside, SCIP_Real ref, SCIP_SOL sol, SCIP_Real *cutcoeflin, SCIP_Real cutcoefquad, SCIP_Real cutlhs, SCIP_Real cutrhs, SCIP_Bool islocal, SCIP_Bool success, char *name)

static SCIP_RETCODE	generateCutConvex (SCIP scip, SCIP_CONS cons, SCIP_SIDETYPE violside, SCIP_Real ref, SCIP_Real coef, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool islocal, SCIP_Bool success, char *name)

static SCIP_RETCODE	generateCutNonConvex (SCIP scip, SCIP_CONS cons, SCIP_SIDETYPE violside, SCIP_Real ref, SCIP_Real coef, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool islocal, SCIP_Bool success, char *name)

static SCIP_RETCODE	generateCut (SCIP scip, SCIP_CONSHDLR conshdlr, SCIP_CONS cons, SCIP_Real ref, SCIP_SOL sol, SCIP_SIDETYPE violside, SCIP_ROW row, SCIP_Real efficacy, SCIP_Bool checkcurvmultivar, SCIP_Real minefficacy)

static SCIP_RETCODE	computeInteriorPoint (SCIP scip, SCIP_CONS cons, char method, SCIP_Bool *success)

static SCIP_RETCODE	computeGauge (SCIP scip, SCIP_CONSHDLR conshdlr, SCIP_CONS *cons)

static SCIP_RETCODE	evaluateGauge (SCIP scip, SCIP_CONSHDLR conshdlr, SCIP_CONS cons, SCIP_SOL refsol, SCIP_Real gaugeval, SCIP_Bool success)

static SCIP_RETCODE	computeReferencePointGauge (SCIP scip, SCIP_CONSHDLR conshdlr, SCIP_CONS cons, SCIP_SOL refsol, SCIP_Real *ref, SCIP_Bool success)

static SCIP_RETCODE	generateCutSol (SCIP scip, SCIP_CONSHDLR conshdlr, SCIP_CONS cons, SCIP_SOL sol, SCIP_SOL refsol, SCIP_SIDETYPE violside, SCIP_ROW row, SCIP_Real efficacy, SCIP_Bool checkcurvmultivar, SCIP_Real minefficacy)

static SCIP_RETCODE	generateCutUnboundedLP (SCIP scip, SCIP_CONSHDLR conshdlr, SCIP_CONS cons, SCIP_SIDETYPE violside, SCIP_ROW row, SCIP_Real rowrayprod, SCIP_Bool checkcurvmultivar)

static SCIP_RETCODE	separatePoint (SCIP scip, SCIP_CONSHDLR conshdlr, SCIP_CONS *conss, int nconss, int nusefulconss, SCIP_SOL sol, SCIP_Real minefficacy, SCIP_Bool inenforcement, SCIP_RESULT result, SCIP_Real bestefficacy)

static SCIP_RETCODE	addLinearizationCuts (SCIP scip, SCIP_CONSHDLR conshdlr, SCIP_CONS *conss, int nconss, SCIP_SOL ref, SCIP_Bool *separatedlpsol, SCIP_Real minefficacy)

static	SCIP_DECL_EVENTEXEC (processNewSolutionEvent)

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

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

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

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

static SCIP_RETCODE	registerLargeLPValueVariableForBranching (SCIP scip, SCIP_CONS conss, int nconss, SCIP_VAR *brvar)

static SCIP_RETCODE	replaceByLinearConstraints (SCIP scip, SCIP_CONS conss, int nconss, SCIP_Bool addedcons, SCIP_Bool reduceddom, SCIP_Bool infeasible)

static SCIP_RETCODE	propagateBoundsTightenVarLb (SCIP scip, SCIP_CONS cons, SCIP_Real intervalinfty, SCIP_VAR var, SCIP_Real bnd, SCIP_RESULT result, int *nchgbds)

static SCIP_RETCODE	propagateBoundsTightenVarUb (SCIP scip, SCIP_CONS cons, SCIP_Real intervalinfty, SCIP_VAR var, SCIP_Real bnd, SCIP_RESULT result, int *nchgbds)

static SCIP_RETCODE	propagateBoundsQuadVar (SCIP scip, SCIP_CONS cons, SCIP_Real intervalinfty, SCIP_VAR var, SCIP_Real a, SCIP_INTERVAL b, SCIP_INTERVAL rhs, SCIP_RESULT result, int *nchgbds)

static SCIP_RETCODE	propagateBoundsBilinearTerm (SCIP scip, SCIP_CONS cons, SCIP_Real intervalinfty, SCIP_VAR x, SCIP_Real xsqrcoef, SCIP_Real xlincoef, SCIP_VAR y, SCIP_Real ysqrcoef, SCIP_Real ylincoef, SCIP_Real bilincoef, SCIP_INTERVAL rhs, SCIP_RESULT result, int nchgbds)

static void	propagateBoundsGetQuadActivity (SCIP scip, SCIP_CONSDATA consdata, SCIP_Real intervalinfty, SCIP_Real minquadactivity, SCIP_Real maxquadactivity, int minactivityinf, int maxactivityinf, SCIP_INTERVAL *quadactcontr)

static SCIP_RETCODE	propagateBoundsCons (SCIP scip, SCIP_CONSHDLR conshdlr, SCIP_CONS cons, SCIP_RESULT result, int nchgbds, SCIP_Bool redundant)

static SCIP_RETCODE	propagateBounds (SCIP scip, SCIP_CONSHDLR conshdlr, SCIP_CONS *conss, int nconss, SCIP_RESULT result, int *nchgbds)

static void	consdataFindUnlockedLinearVar (SCIP scip, SCIP_CONSDATA consdata)

static SCIP_RETCODE	proposeFeasibleSolution (SCIP scip, SCIP_CONSHDLR conshdlr, SCIP_CONS *conss, int nconss, SCIP_SOL sol, SCIP_Bool *success)

static	SCIP_DECL_NONLINCONSUPGD (nonlinconsUpgdQuadratic)

static	SCIP_DECL_CONSHDLRCOPY (conshdlrCopyQuadratic)

static	SCIP_DECL_CONSFREE (consFreeQuadratic)

static	SCIP_DECL_CONSINIT (consInitQuadratic)

static	SCIP_DECL_CONSEXIT (consExitQuadratic)

static	SCIP_DECL_CONSEXITPRE (consExitpreQuadratic)

static	SCIP_DECL_CONSINITSOL (consInitsolQuadratic)

static	SCIP_DECL_CONSEXITSOL (consExitsolQuadratic)

static	SCIP_DECL_CONSDELETE (consDeleteQuadratic)

static	SCIP_DECL_CONSTRANS (consTransQuadratic)

static	SCIP_DECL_CONSINITLP (consInitlpQuadratic)

static	SCIP_DECL_CONSSEPALP (consSepalpQuadratic)

static	SCIP_DECL_CONSSEPASOL (consSepasolQuadratic)

static	SCIP_DECL_CONSENFOLP (consEnfolpQuadratic)

static	SCIP_DECL_CONSENFOPS (consEnfopsQuadratic)

static	SCIP_DECL_CONSPROP (consPropQuadratic)

static	SCIP_DECL_CONSPRESOL (consPresolQuadratic)

static	SCIP_DECL_CONSLOCK (consLockQuadratic)

static	SCIP_DECL_CONSENABLE (consEnableQuadratic)

static	SCIP_DECL_CONSDISABLE (consDisableQuadratic)

static	SCIP_DECL_CONSPRINT (consPrintQuadratic)

static	SCIP_DECL_CONSCHECK (consCheckQuadratic)

static	SCIP_DECL_CONSCOPY (consCopyQuadratic)

static	SCIP_DECL_CONSPARSE (consParseQuadratic)

static	SCIP_DECL_CONSGETVARS (consGetVarsQuadratic)

static	SCIP_DECL_CONSGETNVARS (consGetNVarsQuadratic)

SCIP_RETCODE	SCIPincludeConshdlrQuadratic (SCIP *scip)

SCIP_RETCODE	SCIPincludeQuadconsUpgrade (SCIP scip, SCIP_DECL_QUADCONSUPGD((quadconsupgd)), int priority, SCIP_Bool active, const char *conshdlrname)

SCIP_RETCODE	SCIPcreateConsQuadratic (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	SCIPcreateConsBasicQuadratic (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	SCIPcreateConsQuadratic2 (SCIP scip, SCIP_CONS cons, const char name, int nlinvars, SCIP_VAR *linvars, SCIP_Real lincoefs, int nquadvarterms, SCIP_QUADVARTERM quadvarterms, int nbilinterms, SCIP_BILINTERM bilinterms, 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	SCIPcreateConsBasicQuadratic2 (SCIP scip, SCIP_CONS cons, const char name, int nlinvars, SCIP_VAR *linvars, SCIP_Real lincoefs, int nquadvarterms, SCIP_QUADVARTERM quadvarterms, int nbilinterms, SCIP_BILINTERM bilinterms, SCIP_Real lhs, SCIP_Real rhs)

void	SCIPaddConstantQuadratic (SCIP scip, SCIP_CONS cons, SCIP_Real constant)

SCIP_RETCODE	SCIPaddLinearVarQuadratic (SCIP scip, SCIP_CONS cons, SCIP_VAR *var, SCIP_Real coef)

SCIP_RETCODE	SCIPaddQuadVarQuadratic (SCIP scip, SCIP_CONS cons, SCIP_VAR *var, SCIP_Real lincoef, SCIP_Real sqrcoef)

SCIP_RETCODE	SCIPaddQuadVarLinearCoefQuadratic (SCIP scip, SCIP_CONS cons, SCIP_VAR *var, SCIP_Real coef)

SCIP_RETCODE	SCIPaddSquareCoefQuadratic (SCIP scip, SCIP_CONS cons, SCIP_VAR *var, SCIP_Real coef)

SCIP_RETCODE	SCIPaddBilinTermQuadratic (SCIP scip, SCIP_CONS cons, SCIP_VAR var1, SCIP_VAR var2, SCIP_Real coef)

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

int	SCIPgetNLinearVarsQuadratic (SCIP scip, SCIP_CONS cons)

SCIP_VAR **	SCIPgetLinearVarsQuadratic (SCIP scip, SCIP_CONS cons)

SCIP_Real *	SCIPgetCoefsLinearVarsQuadratic (SCIP scip, SCIP_CONS cons)

int	SCIPgetNQuadVarTermsQuadratic (SCIP scip, SCIP_CONS cons)

SCIP_QUADVARTERM *	SCIPgetQuadVarTermsQuadratic (SCIP scip, SCIP_CONS cons)

SCIP_RETCODE	SCIPsortQuadVarTermsQuadratic (SCIP scip, SCIP_CONS cons)

SCIP_RETCODE	SCIPfindQuadVarTermQuadratic (SCIP scip, SCIP_CONS cons, SCIP_VAR var, int pos)

int	SCIPgetNBilinTermsQuadratic (SCIP scip, SCIP_CONS cons)

SCIP_BILINTERM *	SCIPgetBilinTermsQuadratic (SCIP scip, SCIP_CONS cons)

SCIP_Real	SCIPgetLhsQuadratic (SCIP scip, SCIP_CONS cons)

SCIP_Real	SCIPgetRhsQuadratic (SCIP scip, SCIP_CONS cons)

SCIP_RETCODE	SCIPcheckCurvatureQuadratic (SCIP scip, SCIP_CONS cons)

SCIP_Bool	SCIPisConvexQuadratic (SCIP scip, SCIP_CONS cons)

SCIP_Bool	SCIPisConcaveQuadratic (SCIP scip, SCIP_CONS cons)

SCIP_RETCODE	SCIPgetViolationQuadratic (SCIP scip, SCIP_CONS cons, SCIP_SOL sol, SCIP_Real violation)

SCIP_Bool	SCIPisLinearLocalQuadratic (SCIP scip, SCIP_CONS cons)

SCIP_RETCODE	SCIPaddToNlpiProblemQuadratic (SCIP scip, SCIP_CONS cons, SCIP_NLPI nlpi, SCIP_NLPIPROBLEM nlpiprob, SCIP_HASHMAP *scipvar2nlpivar, SCIP_Bool names)

SCIP_RETCODE	SCIPchgLhsQuadratic (SCIP scip, SCIP_CONS cons, SCIP_Real lhs)

SCIP_RETCODE	SCIPchgRhsQuadratic (SCIP scip, SCIP_CONS cons, SCIP_Real rhs)

SCIP_RETCODE	SCIPgetFeasibilityQuadratic (SCIP scip, SCIP_CONS cons, SCIP_SOL sol, SCIP_Real feasibility)

SCIP_RETCODE	SCIPgetActivityQuadratic (SCIP scip, SCIP_CONS cons, SCIP_SOL sol, SCIP_Real activity)

SCIP_RETCODE	SCIPchgLinearCoefQuadratic (SCIP scip, SCIP_CONS cons, SCIP_VAR *var, SCIP_Real coef)

SCIP_RETCODE	SCIPchgSquareCoefQuadratic (SCIP scip, SCIP_CONS cons, SCIP_VAR *var, SCIP_Real coef)

SCIP_RETCODE	SCIPchgBilinCoefQuadratic (SCIP scip, SCIP_CONS cons, SCIP_VAR var1, SCIP_VAR var2, SCIP_Real coef)

Macro Definition Documentation

#define CONSHDLR_NAME "quadratic"

Definition at line 52 of file cons_quadratic.c.

Referenced by SCIP_DECL_CONSEXITSOL(), SCIP_DECL_CONSHDLRCOPY(), SCIP_DECL_CONSINITSOL(), SCIPchgBilinCoefQuadratic(), SCIPchgLhsQuadratic(), SCIPchgLinearCoefQuadratic(), SCIPchgRhsQuadratic(), SCIPchgSquareCoefQuadratic(), SCIPcreateConsQuadratic(), SCIPcreateConsQuadratic2(), SCIPgetActivityQuadratic(), SCIPgetFeasibilityQuadratic(), SCIPincludeConshdlrQuadratic(), and SCIPincludeQuadconsUpgrade().

#define CONSHDLR_DESC "quadratic constraints of the form lhs <= b' x + x' A x <= rhs"

Definition at line 53 of file cons_quadratic.c.

Referenced by SCIPincludeConshdlrQuadratic().

#define CONSHDLR_SEPAPRIORITY 10

priority of the constraint handler for separation

Definition at line 54 of file cons_quadratic.c.

Referenced by SCIPincludeConshdlrQuadratic().

#define CONSHDLR_ENFOPRIORITY -50

priority of the constraint handler for constraint enforcing

Definition at line 55 of file cons_quadratic.c.

Referenced by SCIPincludeConshdlrQuadratic().

#define CONSHDLR_CHECKPRIORITY -4000000

priority of the constraint handler for checking feasibility

Definition at line 56 of file cons_quadratic.c.

Referenced by SCIPincludeConshdlrQuadratic().

#define CONSHDLR_SEPAFREQ 1

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

Definition at line 57 of file cons_quadratic.c.

Referenced by SCIPincludeConshdlrQuadratic().

#define CONSHDLR_PROPFREQ 1

frequency for propagating domains; zero means only preprocessing propagation

Definition at line 58 of file cons_quadratic.c.

Referenced by SCIPincludeConshdlrQuadratic().

#define CONSHDLR_EAGERFREQ 100

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

Definition at line 59 of file cons_quadratic.c.

Referenced by SCIPincludeConshdlrQuadratic().

#define CONSHDLR_MAXPREROUNDS -1

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

Definition at line 62 of file cons_quadratic.c.

Referenced by SCIPincludeConshdlrQuadratic().

#define CONSHDLR_DELAYSEPA FALSE

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

Definition at line 63 of file cons_quadratic.c.

Referenced by SCIPincludeConshdlrQuadratic().

#define CONSHDLR_DELAYPROP FALSE

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

Definition at line 64 of file cons_quadratic.c.

Referenced by SCIPincludeConshdlrQuadratic().

#define CONSHDLR_NEEDSCONS TRUE

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

Definition at line 65 of file cons_quadratic.c.

Referenced by SCIPincludeConshdlrQuadratic().

#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP

propagation timing mask of the constraint handler

Definition at line 67 of file cons_quadratic.c.

Referenced by SCIPincludeConshdlrQuadratic().

#define CONSHDLR_PRESOLTIMING SCIP_PRESOLTIMING_ALWAYS

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

Definition at line 68 of file cons_quadratic.c.

Referenced by SCIPincludeConshdlrQuadratic().

#define MAXDNOM 10000LL

maximal denominator for simple rational fixed values

Definition at line 70 of file cons_quadratic.c.

Referenced by presolveTryAddLinearReform().

#define NONLINCONSUPGD_PRIORITY 40000

priority of upgrading nonlinear constraints

Definition at line 71 of file cons_quadratic.c.

Referenced by SCIPincludeConshdlrQuadratic().

#define INITLPMAXVARVAL 1000.0

maximal absolute value of variable for still generating a linearization cut at that point in initlp

Definition at line 72 of file cons_quadratic.c.

Referenced by SCIP_DECL_CONSINITLP().

#define PROPBILINNEW

Definition at line 82 of file cons_quadratic.c.

#define INTERIOR_EPS 1e-1

Definition at line 85 of file cons_quadratic.c.

Referenced by computeInteriorPoint().

#define GAUGESCALE 0.99999

Definition at line 88 of file cons_quadratic.c.

Referenced by computeReferencePointGauge().

#define infty2infty	(	infty1,
		infty2,
		val
	)	((val) >= (infty1) ? (infty2) : (val))

translate from one value of infinity to another

if val is >= infty1, then give infty2, else give val

Definition at line 268 of file cons_quadratic.c.

Referenced by propagateBoundsBilinearTerm(), propagateBoundsCons(), and propagateBoundsGetQuadActivity().

Typedef Documentation

typedef struct SCIP_QuadConsUpgrade SCIP_QUADCONSUPGRADE

quadratic constraint update method

Definition at line 182 of file cons_quadratic.c.

Function Documentation

static SCIP_Bool conshdlrdataHasUpgrade	(	SCIP *	scip,
		SCIP_CONSHDLRDATA *	conshdlrdata,
		SCIP_DECL_QUADCONSUPGD((*quadconsupgd))	,
		const char *	conshdlrname
	)

static

checks whether a quadratic constraint upgrade method has already be registered

Parameters

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

Definition at line 234 of file cons_quadratic.c.

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

Referenced by SCIPincludeQuadconsUpgrade().

static SCIP_RETCODE catchLinearVarEvents	(	SCIP *	scip,
		SCIP_EVENTHDLR *	eventhdlr,
		SCIP_CONS *	cons,
		int	linvarpos
	)

static

catches variable bound change events on a linear variable in a quadratic constraint

Parameters

scip	SCIP data structure
eventhdlr	event handler
cons	constraint for which to catch bound change events
linvarpos	position of variable in linear variables array

Definition at line 272 of file cons_quadratic.c.

References dropLinearVarEvents(), NULL, SCIP_CALL, SCIP_EVENTTYPE_LBCHANGED, SCIP_EVENTTYPE_UBCHANGED, SCIP_EVENTTYPE_VARFIXED, SCIP_INVALID, SCIP_OKAY, SCIPallocBlockMemory, SCIPcatchVarEvent(), SCIPconsGetData(), and SCIPisInfinity().

Referenced by addLinearCoef(), catchVarEvents(), and chgLinearCoefPos().

static SCIP_RETCODE dropLinearVarEvents	(	SCIP *	scip,
		SCIP_EVENTHDLR *	eventhdlr,
		SCIP_CONS *	cons,
		int	linvarpos
	)

static

drops variable bound change events on a linear variable in a quadratic constraint

Parameters

scip	SCIP data structure
eventhdlr	event handler
cons	constraint for which to catch bound change events
linvarpos	position of variable in linear variables array

Definition at line 337 of file cons_quadratic.c.

References catchQuadVarEvents(), NULL, SCIP_CALL, SCIP_EVENTTYPE_LBCHANGED, SCIP_EVENTTYPE_UBCHANGED, SCIP_EVENTTYPE_VARFIXED, SCIP_OKAY, SCIPconsGetData(), SCIPdropVarEvent(), SCIPfreeBlockMemory, and SCIPisInfinity().

Referenced by catchLinearVarEvents(), chgLinearCoefPos(), delLinearCoefPos(), and dropVarEvents().

static SCIP_RETCODE catchQuadVarEvents	(	SCIP *	scip,
		SCIP_EVENTHDLR *	eventhdlr,
		SCIP_CONS *	cons,
		int	quadvarpos
	)

static

catches variable bound change events on a quadratic variable in a quadratic constraint

Parameters

scip	SCIP data structure
eventhdlr	event handler
cons	constraint for which to catch bound change events
quadvarpos	position of variable in quadratic variables array

Definition at line 391 of file cons_quadratic.c.

References dropQuadVarEvents(), NULL, SCIP_CALL, SCIP_EVENTTYPE_BOUNDCHANGED, SCIP_EVENTTYPE_IMPLADDED, SCIP_EVENTTYPE_VARFIXED, SCIP_OKAY, SCIPallocBlockMemory, SCIPcatchVarEvent(), SCIPconsGetData(), and SCIPintervalSetEmpty().

Referenced by addQuadVarTerm(), catchVarEvents(), dropLinearVarEvents(), and replaceQuadVarTermPos().

static SCIP_RETCODE dropQuadVarEvents	(	SCIP *	scip,
		SCIP_EVENTHDLR *	eventhdlr,
		SCIP_CONS *	cons,
		int	quadvarpos
	)

static

catches variable bound change events on a quadratic variable in a quadratic constraint

Parameters

scip	SCIP data structure
eventhdlr	event handler
cons	constraint for which to catch bound change events
quadvarpos	position of variable in quadratic variables array

Definition at line 436 of file cons_quadratic.c.

References catchVarEvents(), NULL, SCIP_CALL, SCIP_EVENTTYPE_BOUNDCHANGED, SCIP_EVENTTYPE_IMPLADDED, SCIP_EVENTTYPE_VARFIXED, SCIP_OKAY, SCIPconsGetData(), SCIPdropVarEvent(), and SCIPfreeBlockMemory.

Referenced by catchQuadVarEvents(), delQuadVarTermPos(), dropVarEvents(), and replaceQuadVarTermPos().

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

static

catch variable events

Parameters

scip	SCIP data structure
eventhdlr	event handler
cons	constraint for which to catch bound change events

Definition at line 474 of file cons_quadratic.c.

References catchLinearVarEvents(), catchQuadVarEvents(), dropVarEvents(), FALSE, NULL, SCIP_CALL, SCIP_OKAY, SCIPallocBlockMemoryArray, SCIPconsGetData(), SCIPvarIsActive(), and TRUE.

Referenced by dropQuadVarEvents(), and SCIP_DECL_CONSENABLE().

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

static

drop variable events

Parameters

scip	SCIP data structure
eventhdlr	event handler
cons	constraint for which to drop bound change events

Definition at line 518 of file cons_quadratic.c.

References dropLinearVarEvents(), dropQuadVarEvents(), lockLinearVariable(), NULL, SCIP_CALL, SCIP_OKAY, SCIPconsGetData(), and SCIPfreeBlockMemoryArray.

Referenced by catchVarEvents(), and SCIP_DECL_CONSDISABLE().

static SCIP_RETCODE lockLinearVariable	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var,
		SCIP_Real	coef
	)

static

locks a linear variable in a constraint

Parameters

scip	SCIP data structure
cons	constraint where to lock a variable
var	variable to lock
coef	coefficient of variable in constraint

Definition at line 559 of file cons_quadratic.c.

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

Referenced by addLinearCoef(), chgLinearCoefPos(), and dropVarEvents().

static SCIP_RETCODE unlockLinearVariable	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var,
		SCIP_Real	coef
	)

static

unlocks a linear variable in a constraint

Parameters

scip	SCIP data structure
cons	constraint where to unlock a variable
var	variable to unlock
coef	coefficient of variable in constraint

Definition at line 590 of file cons_quadratic.c.

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

Referenced by chgLinearCoefPos(), delLinearCoefPos(), and lockLinearVariable().

static SCIP_RETCODE lockQuadraticVariable	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var
	)

static

locks a quadratic variable in a constraint

Parameters

scip	SCIP data structure
cons	constraint where to lock a variable
var	variable to lock

Definition at line 621 of file cons_quadratic.c.

References SCIP_CALL, SCIP_OKAY, SCIPlockVarCons(), TRUE, and unlockQuadraticVariable().

Referenced by addQuadVarTerm(), replaceQuadVarTermPos(), and unlockLinearVariable().

static SCIP_RETCODE unlockQuadraticVariable	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var
	)

static

unlocks a quadratic variable in a constraint

Parameters

scip	SCIP data structure
cons	constraint where to unlock a variable
var	variable to unlock

Definition at line 634 of file cons_quadratic.c.

References consdataUpdateLinearActivity(), SCIP_CALL, SCIP_OKAY, SCIPunlockVarCons(), and TRUE.

Referenced by delQuadVarTermPos(), lockQuadraticVariable(), and replaceQuadVarTermPos().

static void consdataUpdateLinearActivity	(	SCIP *	scip,
		SCIP_CONSDATA *	consdata,
		SCIP_Real	intervalinfty
	)

static

computes the minimal and maximal activity for the linear part in a constraint data

Only sums up terms that contribute finite values. Gives the number of terms that contribute infinite values. Only computes those activities where the corresponding side of the constraint is finite.

Parameters

scip	SCIP data structure
consdata	constraint data
intervalinfty	infinity value used in interval operations

Definition at line 652 of file cons_quadratic.c.

References consdataUpdateLinearActivityLbChange(), MAX, MIN, NULL, SCIP_INVALID, SCIP_Real, SCIPintervalGetRoundingMode(), SCIPintervalSetRoundingMode(), SCIPintervalSetRoundingModeDownwards(), SCIPintervalSetRoundingModeUpwards(), SCIPisInfinity(), SCIPvarGetLbLocal(), and SCIPvarGetUbLocal().

Referenced by propagateBoundsCons(), and unlockQuadraticVariable().

static void consdataUpdateLinearActivityLbChange	(	SCIP *	scip,
		SCIP_CONSDATA *	consdata,
		SCIP_Real	coef,
		SCIP_Real	oldbnd,
		SCIP_Real	newbnd
	)

static

update the linear activities after a change in the lower bound of a variable

Parameters

scip	SCIP data structure
consdata	constraint data
coef	coefficient of variable in constraint
oldbnd	previous lower bound of variable
newbnd	new lower bound of variable

Definition at line 766 of file cons_quadratic.c.

References consdataUpdateLinearActivityUbChange(), NULL, SCIP_INVALID, SCIP_Real, SCIPintervalGetRoundingMode(), SCIPintervalSetRoundingMode(), SCIPintervalSetRoundingModeDownwards(), SCIPintervalSetRoundingModeUpwards(), and SCIPisInfinity().

Referenced by consdataUpdateLinearActivity(), and SCIP_DECL_EVENTEXEC().

static void consdataUpdateLinearActivityUbChange	(	SCIP *	scip,
		SCIP_CONSDATA *	consdata,
		SCIP_Real	coef,
		SCIP_Real	oldbnd,
		SCIP_Real	newbnd
	)

static

update the linear activities after a change in the upper bound of a variable

Parameters

scip	SCIP data structure
consdata	constraint data
coef	coefficient of variable in constraint
oldbnd	previous lower bound of variable
newbnd	new lower bound of variable

Definition at line 869 of file cons_quadratic.c.

References NULL, SCIP_DECL_EVENTEXEC(), SCIP_INVALID, SCIP_Real, SCIPintervalGetRoundingMode(), SCIPintervalSetRoundingMode(), SCIPintervalSetRoundingModeDownwards(), SCIPintervalSetRoundingModeUpwards(), and SCIPisInfinity().

Referenced by consdataUpdateLinearActivityLbChange(), and SCIP_DECL_EVENTEXEC().

static SCIP_DECL_EVENTEXEC ( processVarEvent )

static

processes variable fixing or bound change event

Definition at line 972 of file cons_quadratic.c.

References consdataEnsureLinearVarsSize(), consdataUpdateLinearActivityLbChange(), consdataUpdateLinearActivityUbChange(), FALSE, SCIP_QuadVarTerm::nadjbilin, NULL, SCIP_EVENTTYPE_BOUNDCHANGED, SCIP_EVENTTYPE_BOUNDTIGHTENED, SCIP_EVENTTYPE_IMPLADDED, SCIP_EVENTTYPE_LBCHANGED, SCIP_EVENTTYPE_LBTIGHTENED, SCIP_EVENTTYPE_UBTIGHTENED, SCIP_EVENTTYPE_VARFIXED, SCIP_OKAY, SCIP_STAGE_SOLVING, SCIP_VARTYPE_INTEGER, SCIPeventGetNewbound(), SCIPeventGetOldbound(), SCIPeventGetType(), SCIPeventGetVar(), SCIPgetStage(), SCIPintervalSetEmpty(), SCIPvarGetLbGlobal(), SCIPvarGetType(), SCIPvarGetUbGlobal(), SCIPvarIsBinary(), SCIP_QuadVarTerm::sqrcoef, TRUE, and SCIP_QuadVarTerm::var.

Referenced by addLinearizationCuts(), and consdataUpdateLinearActivityUbChange().

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

static

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

Parameters

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

Definition at line 1051 of file cons_quadratic.c.

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

Referenced by addLinearCoef(), presolveDisaggregate(), removeFixedVariables(), SCIP_DECL_EVENTEXEC(), and SCIPcreateConsQuadratic().

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

static

ensures, that quadratic variable terms array can store at least num entries

Parameters

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

Definition at line 1081 of file cons_quadratic.c.

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

Referenced by addQuadVarTerm(), consdataEnsureLinearVarsSize(), and removeFixedVariables().

static SCIP_RETCODE consdataEnsureAdjBilinSize	(	SCIP *	scip,
		SCIP_QUADVARTERM *	quadvarterm,
		int	num
	)

static

ensures, that adjacency array can store at least num entries

Parameters

scip	SCIP data structure
quadvarterm	quadratic variable term
num	minimum number of entries to store

Definition at line 1106 of file cons_quadratic.c.

References SCIP_QuadVarTerm::adjbilin, SCIP_QuadVarTerm::adjbilinsize, consdataEnsureBilinSize(), SCIP_QuadVarTerm::nadjbilin, NULL, SCIP_CALL, SCIP_OKAY, SCIPcalcMemGrowSize(), and SCIPreallocBlockMemoryArray.

Referenced by addBilinearTerm(), consdataEnsureQuadVarTermsSize(), and mergeAndCleanQuadVarTerms().

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

static

ensures, that bilinear term arrays can store at least num entries

Parameters

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

Definition at line 1131 of file cons_quadratic.c.

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

Referenced by addBilinearTerm(), consdataEnsureAdjBilinSize(), removeFixedVariables(), and SCIPcreateConsQuadratic().

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

static

creates empty constraint data structure

Parameters

scip	SCIP data structure
consdata	a buffer to store pointer to new constraint data

Definition at line 1156 of file cons_quadratic.c.

References BMSclearMemory, consdataCreate(), FALSE, NULL, SCIP_CALL, SCIP_INVALID, SCIP_OKAY, SCIPallocBlockMemory, SCIPinfinity(), and TRUE.

Referenced by consdataEnsureBilinSize(), and SCIPcreateConsQuadratic().

static SCIP_RETCODE consdataCreate	(	SCIP *	scip,
		SCIP_CONSDATA **	consdata,
		SCIP_Real	lhs,
		SCIP_Real	rhs,
		int	nlinvars,
		SCIP_VAR **	linvars,
		SCIP_Real *	lincoefs,
		int	nquadvars,
		SCIP_QUADVARTERM *	quadvarterms,
		int	nbilinterms,
		SCIP_BILINTERM *	bilinterms,
		SCIP_Bool	capturevars
	)

static

creates constraint data structure

Parameters

scip	SCIP data structure
consdata	a buffer to store pointer to new constraint data
lhs	left hand side of constraint
rhs	right hand side of constraint
nlinvars	number of linear variables
linvars	array of linear variables
lincoefs	array of coefficients of linear variables
nquadvars	number of quadratic variables
quadvarterms	array of quadratic variable terms
nbilinterms	number of bilinear terms
bilinterms	array of bilinear terms
capturevars	whether we should capture variables

Definition at line 1196 of file cons_quadratic.c.

References SCIP_QuadVarTerm::adjbilin, BMSclearMemory, consdataFree(), FALSE, SCIP_QuadVarTerm::nadjbilin, NULL, SCIP_CALL, SCIP_INVALID, SCIP_OKAY, SCIPallocBlockMemory, SCIPcaptureVar(), SCIPduplicateBlockMemoryArray, SCIPintervalSet(), SCIPintervalSetEmpty(), SCIPisInfinity(), and TRUE.

Referenced by consdataCreateEmpty(), SCIP_DECL_CONSTRANS(), and SCIPcreateConsQuadratic2().

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

static

frees constraint data structure

Parameters

scip	SCIP data structure
consdata	pointer to constraint data to free

Definition at line 1316 of file cons_quadratic.c.

References consdataSortLinearVars(), NULL, SCIP_CALL, SCIP_OKAY, SCIPfreeBlockMemory, SCIPfreeBlockMemoryArray, SCIPfreeBlockMemoryArrayNull, SCIPfreeMemoryArrayNull, SCIPreleaseNlRow(), and SCIPreleaseVar().

Referenced by consdataCreate(), and SCIP_DECL_CONSDELETE().

static void consdataSortLinearVars ( SCIP_CONSDATA * consdata )

static

sorts linear part of constraint data

Parameters

consdata quadratic constraint data

Definition at line 1377 of file cons_quadratic.c.

References NULL, SCIP_DECL_SORTINDCOMP(), SCIPsortedvecFindPtr(), SCIPsortPtrPtrReal(), SCIPsortPtrReal(), and TRUE.

Referenced by consdataFree(), and mergeAndCleanLinearVars().

static SCIP_DECL_SORTINDCOMP ( quadVarTermComp )

static

index comparison method for quadratic variable terms: compares two indices of the quadratic variable set in the quadratic constraint

Definition at line 1438 of file cons_quadratic.c.

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

Referenced by consdataFindQuadVarTerm(), and consdataSortLinearVars().

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

static

sorting of quadratic variable terms

Parameters

scip	SCIP data structure
consdata	quadratic constraint data

Definition at line 1451 of file cons_quadratic.c.

References consdataFindQuadVarTerm(), SCIP_QuadVarTerm::eventdata, NULL, SCIP_CALL, SCIP_OKAY, SCIPallocBufferArray, SCIPfreeBufferArray, SCIPsort(), and TRUE.

Referenced by checkFactorable(), consdataFindQuadVarTerm(), mergeAndCleanQuadVarTerms(), presolveDisaggregate(), propagateBoundsCons(), SCIP_DECL_CONSINITSOL(), SCIP_DECL_SORTINDCOMP(), SCIPaddBilinTermQuadratic(), and SCIPsortQuadVarTermsQuadratic().

static SCIP_RETCODE consdataFindQuadVarTerm	(	SCIP *	scip,
		SCIP_CONSDATA *	consdata,
		SCIP_VAR *	var,
		int *	pos
	)

static

returns the position of variable in the quadratic variable terms array of a constraint, or -1 if not found

Parameters

scip	SCIP data structure
consdata	quadratic constraint data
var	variable to search for
pos	buffer where to store position of var in quadvarterms array, or -1 if not found

Definition at line 1520 of file cons_quadratic.c.

References consdataSortQuadVarTerms(), NULL, SCIP_CALL, SCIP_DECL_SORTINDCOMP(), SCIP_OKAY, and SCIPvarCompare().

Referenced by checkFactorable(), consdataSortQuadVarTerms(), createNlRow(), mergeAndCleanLinearVars(), presolveDisaggregateMarkComponent(), propagateBoundsCons(), SCIP_DECL_CONSINITSOL(), SCIPaddBilinTermQuadratic(), SCIPaddQuadVarLinearCoefQuadratic(), SCIPaddSquareCoefQuadratic(), and SCIPfindQuadVarTermQuadratic().

static SCIP_DECL_SORTINDCOMP ( bilinTermComp )

static

index comparison method for bilinear terms: compares two index pairs of the bilinear term set in the quadratic constraint

Definition at line 1573 of file cons_quadratic.c.

References consdataCheckBilinTermsSort(), NULL, SCIP_Bool, and SCIPvarCompare().

static SCIP_Bool consdataCheckBilinTermsSort ( SCIP_CONSDATA * consdata )

static

checks if all bilinear terms are sorted correctly

Definition at line 1592 of file cons_quadratic.c.

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

Referenced by addBilinearTerm(), consdataSortBilinTerms(), mergeAndCleanBilinearTerms(), and SCIP_DECL_SORTINDCOMP().

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

static

sorting of bilinear terms

Parameters

scip	SCIP data structure
consdata	quadratic constraint data

Definition at line 1615 of file cons_quadratic.c.

References consdataCheckBilinTermsSort(), consdataMoveLinearVar(), NULL, SCIP_CALL, SCIP_OKAY, SCIPallocBufferArray, SCIPfreeBufferArray, SCIPsort(), and TRUE.

Referenced by consdataCheckBilinTermsSort(), and mergeAndCleanBilinearTerms().

static void consdataMoveLinearVar	(	SCIP_CONSDATA *	consdata,
		int	oldpos,
		int	newpos
	)

static

moves a linear variable from one position to another

Parameters

consdata	constraint data
oldpos	position of variable that shall be moved
newpos	new position of variable

Definition at line 1693 of file cons_quadratic.c.

References consdataMoveQuadVarTerm(), FALSE, and NULL.

Referenced by consdataSortBilinTerms(), and delLinearCoefPos().

static void consdataMoveQuadVarTerm	(	SCIP_CONSDATA *	consdata,
		int	oldpos,
		int	newpos
	)

static

moves a quadratic variable from one position to another

Parameters

consdata	constraint data
oldpos	position of variable that shall be moved
newpos	new position of variable

Definition at line 1726 of file cons_quadratic.c.

References addLinearCoef(), FALSE, and NULL.

Referenced by consdataMoveLinearVar(), and delQuadVarTermPos().

static SCIP_RETCODE addLinearCoef	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var,
		SCIP_Real	coef
	)

static

adds linear coefficient in quadratic constraint

Parameters

scip	SCIP data structure
cons	quadratic constraint
var	variable of constraint entry
coef	coefficient of constraint entry

Definition at line 1756 of file cons_quadratic.c.

References catchLinearVarEvents(), consdataEnsureLinearVarsSize(), delLinearCoefPos(), FALSE, lockLinearVariable(), NULL, SCIP_Bool, SCIP_CALL, SCIP_INVALID, SCIP_OKAY, SCIPcaptureVar(), SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetData(), SCIPconsIsEnabled(), SCIPconsIsTransformed(), SCIPgetTransformedVar(), SCIPisZero(), SCIPreleaseNlRow(), SCIPvarCompare(), SCIPvarIsActive(), SCIPvarIsTransformed(), and TRUE.

Referenced by consdataMoveQuadVarTerm(), mergeAndCleanQuadVarTerms(), presolveDisaggregate(), presolveTryAddAND(), presolveTryAddLinearReform(), removeFixedVariables(), SCIPaddLinearVarQuadratic(), SCIPchgLinearCoefQuadratic(), and SCIPcreateConsQuadratic().

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

static

deletes linear coefficient at given position from quadratic constraint data

Parameters

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

Definition at line 1847 of file cons_quadratic.c.

References chgLinearCoefPos(), consdataMoveLinearVar(), dropLinearVarEvents(), FALSE, NULL, SCIP_CALL, SCIP_INVALID, SCIP_OKAY, SCIP_Real, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetData(), SCIPreleaseNlRow(), SCIPreleaseVar(), and unlockLinearVariable().

Referenced by addLinearCoef(), mergeAndCleanLinearVars(), removeFixedVariables(), and SCIPchgLinearCoefQuadratic().

static SCIP_RETCODE chgLinearCoefPos	(	SCIP *	scip,
		SCIP_CONS *	cons,
		int	pos,
		SCIP_Real	newcoef
	)

static

changes linear coefficient value at given position of quadratic constraint

Parameters

scip	SCIP data structure
cons	quadratic constraint
pos	position of linear coefficient to change
newcoef	new value of linear coefficient

Definition at line 1916 of file cons_quadratic.c.

References addQuadVarTerm(), catchLinearVarEvents(), dropLinearVarEvents(), FALSE, lockLinearVariable(), NULL, SCIP_CALL, SCIP_INVALID, SCIP_OKAY, SCIP_Real, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetData(), SCIPconsIsEnabled(), SCIPconsIsLocked(), SCIPconsIsTransformed(), SCIPisZero(), SCIPreleaseNlRow(), SCIPvarIsTransformed(), and unlockLinearVariable().

Referenced by delLinearCoefPos(), mergeAndCleanLinearVars(), and SCIPchgLinearCoefQuadratic().

static SCIP_RETCODE addQuadVarTerm	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var,
		SCIP_Real	lincoef,
		SCIP_Real	sqrcoef
	)

static

adds quadratic variable term to quadratic constraint

Parameters

scip	SCIP data structure
cons	quadratic constraint
var	variable to add
lincoef	linear coefficient of variable
sqrcoef	square coefficient of variable

Definition at line 2012 of file cons_quadratic.c.

References SCIP_QuadVarTerm::adjbilin, SCIP_QuadVarTerm::adjbilinsize, catchQuadVarEvents(), consdataEnsureQuadVarTermsSize(), delQuadVarTermPos(), SCIP_QuadVarTerm::eventdata, FALSE, SCIP_QuadVarTerm::lincoef, lockQuadraticVariable(), SCIP_QuadVarTerm::nadjbilin, NULL, SCIP_Bool, SCIP_CALL, SCIP_INVALID, SCIP_OKAY, SCIPcaptureVar(), SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetData(), SCIPconsIsEnabled(), SCIPconsIsTransformed(), SCIPgetTransformedVar(), SCIPintervalSetEmpty(), SCIPreleaseNlRow(), SCIPvarCompare(), SCIPvarIsActive(), SCIPvarIsTransformed(), SCIP_QuadVarTerm::sqrcoef, TRUE, and SCIP_QuadVarTerm::var.

Referenced by chgLinearCoefPos(), removeFixedVariables(), SCIPaddBilinTermQuadratic(), SCIPaddQuadVarLinearCoefQuadratic(), SCIPaddQuadVarQuadratic(), SCIPaddSquareCoefQuadratic(), SCIPchgSquareCoefQuadratic(), and SCIPcreateConsQuadratic().

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

static

deletes quadratic variable term at given position from quadratic constraint data

Parameters

scip	SCIP data structure
cons	quadratic constraint
pos	position of term to delete

Definition at line 2105 of file cons_quadratic.c.

References consdataMoveQuadVarTerm(), dropQuadVarEvents(), FALSE, NULL, replaceQuadVarTermPos(), SCIP_CALL, SCIP_INVALID, SCIP_OKAY, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetData(), SCIPfreeBlockMemoryArrayNull, SCIPintervalSetEmpty(), SCIPreleaseNlRow(), SCIPreleaseVar(), and unlockQuadraticVariable().

Referenced by addQuadVarTerm(), mergeAndCleanQuadVarTerms(), presolveDisaggregate(), and removeFixedVariables().

static SCIP_RETCODE replaceQuadVarTermPos	(	SCIP *	scip,
		SCIP_CONS *	cons,
		int	pos,
		SCIP_VAR *	var,
		SCIP_Real	coef,
		SCIP_Real	offset
	)

static

replace variable in quadratic variable term at given position of quadratic constraint data

Allows to replace x by coef*y+offset, thereby maintaining linear and square coefficients and bilinear terms.

Parameters

scip	SCIP data structure
cons	quadratic constraint
pos	position of term to replace
var	new variable
coef	linear coefficient of new variable
offset	offset of new variable

Definition at line 2177 of file cons_quadratic.c.

References addBilinearTerm(), SCIP_QuadVarTerm::adjbilin, catchQuadVarEvents(), SCIP_BilinTerm::coef, dropQuadVarEvents(), SCIP_QuadVarTerm::eventdata, FALSE, SCIP_QuadVarTerm::lincoef, lockQuadraticVariable(), SCIP_QuadVarTerm::nadjbilin, NULL, SCIP_CALL, SCIP_INVALID, SCIP_OKAY, SCIP_Real, SCIPcaptureVar(), SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetData(), SCIPconsIsEnabled(), SCIPintervalSetEmpty(), SCIPisInfinity(), SCIPreleaseNlRow(), SCIPreleaseVar(), SCIPvarCompare(), SCIPvarIsActive(), SCIP_QuadVarTerm::sqrcoef, unlockQuadraticVariable(), SCIP_QuadVarTerm::var, SCIP_BilinTerm::var1, and SCIP_BilinTerm::var2.

Referenced by delQuadVarTermPos(), and removeFixedVariables().

static SCIP_RETCODE addBilinearTerm	(	SCIP *	scip,
		SCIP_CONS *	cons,
		int	var1pos,
		int	var2pos,
		SCIP_Real	coef
	)

static

adds a bilinear term to quadratic constraint

Parameters

scip	SCIP data structure
cons	quadratic constraint
var1pos	position of first variable in quadratic variables array
var2pos	position of second variable in quadratic variables array
coef	coefficient of bilinear term

Definition at line 2345 of file cons_quadratic.c.

References SCIP_BilinTerm::coef, consdataCheckBilinTermsSort(), consdataEnsureAdjBilinSize(), consdataEnsureBilinSize(), FALSE, NULL, removeBilinearTermsPos(), SCIP_CALL, SCIP_INVALID, SCIP_INVALIDDATA, SCIP_OKAY, SCIPconsGetData(), SCIPerrorMessage, SCIPintervalSetEmpty(), SCIPisZero(), SCIPreleaseNlRow(), SCIPvarCompare(), TRUE, SCIP_BilinTerm::var1, and SCIP_BilinTerm::var2.

Referenced by removeFixedVariables(), replaceQuadVarTermPos(), SCIPaddBilinTermQuadratic(), and SCIPcreateConsQuadratic().

static SCIP_RETCODE removeBilinearTermsPos	(	SCIP *	scip,
		SCIP_CONS *	cons,
		int	nterms,
		int *	termposs
	)

static

removes a set of bilinear terms and updates adjacency information in quad var terms

Note: this function sorts the given array termposs.

Parameters

scip	SCIP data structure
cons	quadratic constraint
nterms	number of terms to delete
termposs	indices of terms to delete

Definition at line 2447 of file cons_quadratic.c.

References FALSE, mergeAndCleanQuadVarTerms(), NULL, SCIP_CALL, SCIP_INVALID, SCIP_OKAY, SCIPallocBufferArray, SCIPconsGetData(), SCIPfreeBufferArray, SCIPintervalSetEmpty(), SCIPreleaseNlRow(), and SCIPsortInt().

Referenced by addBilinearTerm(), mergeAndCleanBilinearTerms(), presolveTryAddAND(), presolveTryAddLinearReform(), and removeFixedVariables().

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

static

merges quad var terms that correspond to the same variable and does additional cleanup

If a quadratic variable terms is actually linear, makes a linear term out of it also replaces squares of binary variables by the binary variables, i.e., adds sqrcoef to lincoef.

Parameters

scip	SCIP data structure
cons	quadratic constraint

Definition at line 2546 of file cons_quadratic.c.

References addLinearCoef(), SCIP_QuadVarTerm::adjbilin, BMScopyMemoryArray, consdataEnsureAdjBilinSize(), consdataSortQuadVarTerms(), delQuadVarTermPos(), SCIP_QuadVarTerm::lincoef, mergeAndCleanLinearVars(), SCIP_QuadVarTerm::nadjbilin, NULL, SCIP_CALL, SCIP_OKAY, SCIPconsGetData(), SCIPdebugMessage, SCIPintervalSetEmpty(), SCIPisZero(), SCIPreleaseNlRow(), SCIPvarGetName(), SCIPvarIsBinary(), SCIP_QuadVarTerm::sqrcoef, TRUE, and SCIP_QuadVarTerm::var.

Referenced by presolveDisaggregate(), removeBilinearTermsPos(), removeFixedVariables(), SCIP_DECL_CONSENABLE(), SCIP_DECL_CONSEXITPRE(), and SCIP_DECL_CONSPRESOL().

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

static

merges entries with same linear variable into one entry and cleans up entries with coefficient 0.0

Parameters

scip	SCIP data structure
cons	quadratic constraint

Definition at line 2643 of file cons_quadratic.c.

References chgLinearCoefPos(), consdataFindQuadVarTerm(), consdataSortLinearVars(), delLinearCoefPos(), mergeAndCleanBilinearTerms(), NULL, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPconsGetData(), SCIPintervalSetEmpty(), SCIPisZero(), and TRUE.

Referenced by mergeAndCleanQuadVarTerms(), removeFixedVariables(), SCIP_DECL_CONSENABLE(), SCIP_DECL_CONSEXITPRE(), and SCIP_DECL_CONSPRESOL().

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

static

merges bilinear terms with same variables into a single term, removes bilinear terms with coefficient 0.0

Parameters

scip	SCIP data structure
cons	quadratic constraint

Definition at line 2715 of file cons_quadratic.c.

References SCIP_BilinTerm::coef, consdataCheckBilinTermsSort(), consdataSortBilinTerms(), NULL, removeBilinearTermsPos(), removeFixedVariables(), SCIP_CALL, SCIP_OKAY, SCIPallocBufferArray, SCIPconsGetData(), SCIPfreeBufferArray, SCIPisZero(), TRUE, SCIP_BilinTerm::var1, and SCIP_BilinTerm::var2.

Referenced by mergeAndCleanLinearVars(), presolveDisaggregate(), removeFixedVariables(), SCIP_DECL_CONSENABLE(), SCIP_DECL_CONSEXITPRE(), and SCIP_DECL_CONSPRESOL().

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

static

removes fixes (or aggregated) variables from a quadratic constraint

Parameters

scip	SCIP data structure
cons	quadratic constraint

Definition at line 2788 of file cons_quadratic.c.

References addBilinearTerm(), addLinearCoef(), addQuadVarTerm(), SCIP_BilinTerm::coef, consdataEnsureBilinSize(), consdataEnsureLinearVarsSize(), consdataEnsureQuadVarTermsSize(), createNlRow(), delLinearCoefPos(), delQuadVarTermPos(), FALSE, mergeAndCleanBilinearTerms(), mergeAndCleanLinearVars(), mergeAndCleanQuadVarTerms(), NULL, removeBilinearTermsPos(), replaceQuadVarTermPos(), SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIP_VARSTATUS_MULTAGGR, SCIPconsGetData(), SCIPconsGetName(), SCIPdebugMessage, SCIPdebugPrintCons, SCIPgetProbvarSum(), SCIPisInfinity(), SCIPvarCompare(), SCIPvarGetMultaggrConstant(), SCIPvarGetMultaggrNVars(), SCIPvarGetMultaggrScalars(), SCIPvarGetMultaggrVars(), SCIPvarGetName(), SCIPvarGetStatus(), SCIPvarIsActive(), TRUE, SCIP_BilinTerm::var1, and SCIP_BilinTerm::var2.

Referenced by mergeAndCleanBilinearTerms(), SCIP_DECL_CONSEXITPRE(), and SCIP_DECL_CONSPRESOL().

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

static

create a nonlinear row representation of the constraint and stores them in consdata

Parameters

scip	SCIP data structure
cons	quadratic constraint

Definition at line 3099 of file cons_quadratic.c.

References SCIP_QuadElement::coef, consdataFindQuadVarTerm(), SCIP_QuadElement::idx1, SCIP_QuadElement::idx2, MAX, MIN, NULL, presolveSolve(), SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPaddLinearCoefsToNlRow(), SCIPallocBufferArray, SCIPconsGetData(), SCIPconsGetName(), SCIPcreateNlRow(), SCIPfreeBufferArray, SCIPisZero(), and SCIPreleaseNlRow().

Referenced by computeInteriorPoint(), removeFixedVariables(), SCIP_DECL_CONSINITSOL(), and SCIPgetNlRowQuadratic().

static SCIP_RETCODE presolveSolve	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_RESULT *	result,
		SCIP_Bool *	redundant,
		int *	naggrvars
	)

static

solve constraint as presolving

Parameters

scip	SCIP data structure
cons	constraint
result	to store result of solve: cutoff, success, or do-not-find
redundant	to store whether constraint is redundant now (should be deleted)
naggrvars	counter on number of variable aggregations

Definition at line 3217 of file cons_quadratic.c.

References FALSE, NULL, presolveTryAddAND(), SCIP_Bool, SCIP_CALL, SCIP_CUTOFF, SCIP_DIDNOTFIND, SCIP_OKAY, SCIP_Real, SCIP_SUCCESS, SCIPaggregateVars(), SCIPconsGetData(), SCIPdebugMessage, SCIPisEQ(), SCIPisZero(), SCIPvarGetName(), SCIPvarIsBinary(), and TRUE.

Referenced by createNlRow(), and SCIP_DECL_CONSPRESOL().

static SCIP_RETCODE presolveTryAddAND	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_CONS *	cons,
		int *	naddconss
	)

static

reformulates products of binary variables as AND constraint

For a product x*y, with x and y binary variables, the product is replaced by a new auxiliary variable z and the constraint z = {x and y} is added.

Parameters

scip	SCIP data structure
conshdlr	constraint handler
cons	constraint
naddconss	buffer where to add the number of AND constraints added

Definition at line 3304 of file cons_quadratic.c.

References addLinearCoef(), getImpliedBounds(), NULL, removeBilinearTermsPos(), SCIP_CALL, SCIP_MAXSTRLEN, SCIP_OKAY, SCIP_Real, SCIP_VARTYPE_BINARY, SCIPaddCons(), SCIPaddVar(), SCIPallocBufferArray, SCIPconsGetData(), SCIPconsGetName(), SCIPconshdlrGetData(), SCIPconsIsDynamic(), SCIPconsIsInitial(), SCIPconsIsLocal(), SCIPconsIsModifiable(), SCIPconsIsPropagated(), SCIPconsIsRemovable(), SCIPconsIsSeparated(), SCIPconsIsStickingAtNode(), SCIPcreateConsAnd(), SCIPcreateVar(), SCIPdebugAddSolVal, SCIPdebugGetSolVal, SCIPdebugMessage, SCIPdebugPrintCons, SCIPfreeBufferArray, SCIPreleaseCons(), SCIPreleaseVar(), SCIPsnprintf(), SCIPvarGetName(), SCIPvarIsBinary(), SCIPvarIsInitial(), SCIPvarIsRemovable(), and TRUE.

Referenced by presolveSolve(), and SCIP_DECL_CONSPRESOL().

static SCIP_RETCODE getImpliedBounds	(	SCIP *	scip,
		SCIP_VAR *	x,
		SCIP_Bool	xval,
		SCIP_VAR *	y,
		SCIP_INTERVAL *	resultant
	)

static

gets bounds of variable y if x takes a certain value; checks whether x = xval has implications on y

Parameters

scip	SCIP data structure
x	variable which implications to check
xval	value of x to check for (TRUE for 1, FALSE for 0)
y	variable to check if bounds can be reduced
resultant	buffer to store bounds on y

Definition at line 3400 of file cons_quadratic.c.

References FALSE, SCIP_Interval::inf, MAX, MIN, NULL, presolveTryAddLinearReform(), SCIP_BOUNDTYPE_LOWER, SCIP_OKAY, SCIP_Real, SCIPhaveVarsCommonClique(), SCIPintervalSetBounds(), SCIPsortedvecFindPtr(), SCIPvarGetImplBounds(), SCIPvarGetImplTypes(), SCIPvarGetImplVars(), SCIPvarGetLbGlobal(), SCIPvarGetNImpls(), SCIPvarGetUbGlobal(), SCIPvarIsActive(), SCIPvarIsBinary(), SCIP_Interval::sup, and TRUE.

Referenced by presolveDisaggregate(), presolveTryAddAND(), and presolveTryAddLinearReform().

static SCIP_RETCODE presolveTryAddLinearReform	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_CONS *	cons,
		int *	naddconss
	)

static

Reformulates products of binary times bounded continuous variables as system of linear inequalities (plus auxiliary variable).

For a product x*y, with y a binary variable and x a continous variable with finite bounds, an auxiliary variable z and the inequalities $x^L y \leq z \leq x^U y$ and $x - (1-y) x^U \leq z \leq x - (1-y) x^L$ are added.

If x is a linear term consisting of more than one variable, it is split up in groups of linear terms of length at most maxnrvar. For each product of linear term of length at most maxnrvar with y, an auxiliary z and linear inequalities are added.

If y is a binary variable, the AND constraint $z = x \wedge y$ may be added instead of linear constraints.

Parameters

scip	SCIP data structure
conshdlr	constraint handler
cons	constraint
naddconss	buffer where to add the number of auxiliary constraints added

Definition at line 3491 of file cons_quadratic.c.

References addLinearCoef(), FALSE, getImpliedBounds(), SCIP_Interval::inf, MAX, MAXDNOM, MIN, NULL, presolveUpgrade(), REALABS, removeBilinearTermsPos(), SCIP_Bool, SCIP_CALL, SCIP_Longint, SCIP_MAXSTRLEN, SCIP_OKAY, SCIP_Real, SCIP_VARTYPE_CONTINUOUS, SCIP_VARTYPE_IMPLINT, SCIPaddCons(), SCIPaddVar(), SCIPcalcGreComDiv(), SCIPconsGetData(), SCIPconsGetName(), SCIPconshdlrGetData(), SCIPconsIsDynamic(), SCIPconsIsInitial(), SCIPconsIsLocal(), SCIPconsIsModifiable(), SCIPconsIsPropagated(), SCIPconsIsRemovable(), SCIPconsIsSeparated(), SCIPconsIsStickingAtNode(), SCIPcreateConsAnd(), SCIPcreateConsLinear(), SCIPcreateConsVarbound(), SCIPcreateVar(), SCIPdebugAddSolVal, SCIPdebugGetSolVal, SCIPdebugMessage, SCIPdebugPrintCons, SCIPfeastol(), SCIPfreeBufferArrayNull, SCIPinfinity(), SCIPintervalAdd(), SCIPintervalDivScalar(), SCIPintervalGetInf(), SCIPintervalGetSup(), SCIPintervalMulScalar(), SCIPintervalSet(), SCIPisEQ(), SCIPisInfinity(), SCIPisIntegral(), SCIPisNegative(), SCIPisPositive(), SCIPisZero(), SCIPreallocBufferArray, SCIPreleaseCons(), SCIPreleaseVar(), SCIPround(), SCIPselectSimpleValue(), SCIPsnprintf(), SCIPvarGetLbGlobal(), SCIPvarGetName(), SCIPvarGetType(), SCIPvarGetUbGlobal(), SCIPvarIsBinary(), SCIPvarIsInitial(), SCIPvarIsRemovable(), SCIP_Interval::sup, and TRUE.

Referenced by getImpliedBounds(), and SCIP_DECL_CONSPRESOL().

static SCIP_RETCODE presolveUpgrade	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_CONS *	cons,
		SCIP_Bool *	upgraded,
		int *	nupgdconss,
		int *	naddconss,
		SCIP_PRESOLTIMING	presoltiming
	)

static

tries to automatically convert a quadratic constraint (or a part of it) into a more specific and more specialized constraint

Parameters

scip	SCIP data structure
conshdlr	constraint handler data structure
cons	source constraint to try to convert
upgraded	buffer to store whether constraint was upgraded
nupgdconss	buffer to increase if constraint was upgraded
naddconss	buffer to increase with number of additional constraints created during upgrade
presoltiming	current presolving timing

Definition at line 3923 of file cons_quadratic.c.

References FALSE, NULL, presolveDisaggregateMarkComponent(), SCIP_Bool, SCIP_CALL, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_Real, SCIP_VARTYPE_BINARY, SCIP_VARTYPE_CONTINUOUS, SCIP_VARTYPE_IMPLINT, SCIP_VARTYPE_INTEGER, SCIPaddCons(), SCIPallocBufferArray, SCIPconsGetData(), SCIPconsGetName(), SCIPconshdlrGetData(), SCIPconsIsModifiable(), SCIPdebugMessage, SCIPdebugPrintCons, SCIPdebugPrintf, SCIPdelCons(), SCIPerrorMessage, SCIPfreeBufferArray, SCIPisIntegral(), SCIPisRelEQ(), SCIPisZero(), SCIPreallocBufferArray, SCIPreleaseCons(), SCIPvarGetLbLocal(), SCIPvarGetType(), SCIPvarGetUbLocal(), and TRUE.

Referenced by presolveTryAddLinearReform(), and SCIP_DECL_CONSPRESOL().

static SCIP_RETCODE presolveDisaggregateMarkComponent	(	SCIP *	scip,
		SCIP_CONSDATA *	consdata,
		int	quadvaridx,
		SCIP_HASHMAP *	var2component,
		int	componentnr
	)

static

helper function for presolveDisaggregate

Parameters

scip	SCIP data structure
consdata	constraint data
quadvaridx	index of quadratic variable to mark
var2component	variables to components mapping
componentnr	the component number to mark to

Definition at line 4139 of file cons_quadratic.c.

References SCIP_QuadVarTerm::adjbilin, consdataFindQuadVarTerm(), SCIP_QuadVarTerm::nadjbilin, NULL, presolveDisaggregate(), SCIP_CALL, SCIP_OKAY, SCIPhashmapExists(), SCIPhashmapGetImage(), SCIPhashmapInsert(), and SCIP_QuadVarTerm::var.

Referenced by presolveDisaggregate(), and presolveUpgrade().

static SCIP_RETCODE presolveDisaggregate	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_CONS *	cons,
		int *	naddconss
	)

static

for quadratic constraints that consists of a sum of quadratic terms, disaggregates the sum into a set of constraints by introducing auxiliary variables

Parameters

scip	SCIP data structure
conshdlr	constraint handler data structure
cons	source constraint to try to convert
naddconss	pointer to counter of added constraints

Definition at line 4185 of file cons_quadratic.c.

References addLinearCoef(), checkCurvatureEasy(), consdataEnsureLinearVarsSize(), consdataSortQuadVarTerms(), delQuadVarTermPos(), FALSE, getImpliedBounds(), SCIP_Interval::inf, mergeAndCleanBilinearTerms(), mergeAndCleanQuadVarTerms(), NULL, presolveDisaggregateMarkComponent(), REALABS, SCIP_CALL, SCIP_MAXSTRLEN, SCIP_OKAY, SCIP_Real, SCIP_VARTYPE_CONTINUOUS, SCIPaddBilinTermQuadratic(), SCIPaddCons(), SCIPaddLinearVarQuadratic(), SCIPaddQuadVarLinearCoefQuadratic(), SCIPaddQuadVarQuadratic(), SCIPaddVar(), SCIPallocBufferArray, SCIPblkmem(), SCIPcalcHashtableSize(), SCIPconsGetData(), SCIPconsGetName(), SCIPconsIsDynamic(), SCIPconsIsInitial(), SCIPconsIsLocal(), SCIPconsIsModifiable(), SCIPconsIsPropagated(), SCIPconsIsRemovable(), SCIPconsIsSeparated(), SCIPcreateConsQuadratic2(), SCIPcreateVar(), SCIPdebugMessage, SCIPdebugPrintCons, SCIPfreeBlockMemoryArray, SCIPfreeBufferArray, SCIPhashmapCreate(), SCIPhashmapExists(), SCIPhashmapFree(), SCIPhashmapGetImage(), SCIPinfinity(), SCIPisInfinity(), SCIPisZero(), SCIPreleaseCons(), SCIPreleaseNlRow(), SCIPreleaseVar(), SCIPsnprintf(), SCIPvarGetName(), SCIPvarGetNImpls(), SCIPvarIsActive(), SCIPvarIsBinary(), SCIP_Interval::sup, and TRUE.

Referenced by presolveDisaggregateMarkComponent(), and SCIP_DECL_CONSPRESOL().

static void checkCurvatureEasy	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool *	determined,
		SCIP_Bool	checkmultivariate
	)

static

checks a quadratic constraint for convexity and/or concavity without checking multivariate functions

Parameters

scip	SCIP data structure
cons	quadratic constraint
determined	pointer to store whether the curvature could be determined
checkmultivariate	whether curvature will be checked later on for multivariate functions

Definition at line 4460 of file cons_quadratic.c.

References checkCurvature(), FALSE, NULL, SCIPconsGetData(), SCIPconsGetName(), SCIPdebugMessage, SCIPisNegative(), SCIPisPositive(), and TRUE.

Referenced by checkCurvature(), presolveDisaggregate(), SCIPisConcaveQuadratic(), and SCIPisConvexQuadratic().

static SCIP_RETCODE checkCurvature	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Bool	checkmultivariate
	)

static

checks a quadratic constraint for convexity and/or concavity

Parameters

scip	SCIP data structure
cons	quadratic constraint
checkmultivariate	whether curvature should also be checked for multivariate functions

Definition at line 4525 of file cons_quadratic.c.

References BMSclearMemoryArray, checkCurvatureEasy(), checkFactorable(), FALSE, LapackDsyev(), NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIP_VERBLEVEL_FULL, SCIPallocBufferArray, SCIPblkmem(), SCIPcalcHashtableSize(), SCIPconsGetData(), SCIPconsGetName(), SCIPdebugMessage, SCIPfreeBufferArray, SCIPhashmapCreate(), SCIPhashmapExists(), SCIPhashmapFree(), SCIPhashmapGetImage(), SCIPhashmapInsert(), SCIPisInfinity(), SCIPisIpoptAvailableIpopt(), SCIPisNegative(), SCIPisPositive(), SCIPvarIsBinary(), SCIPverbMessage(), SCIPwarningMessage(), and TRUE.

Referenced by addLinearizationCuts(), checkCurvatureEasy(), generateCut(), generateCutUnboundedLP(), SCIP_DECL_CONSINITLP(), SCIP_DECL_CONSINITSOL(), SCIP_DECL_CONSSEPALP(), and SCIPcheckCurvatureQuadratic().

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

static

check whether indefinite constraint function is factorable and store corresponding coefficients

Parameters

scip	SCIP data structure
cons	constraint

Definition at line 4705 of file cons_quadratic.c.

References BMSclearMemoryArray, SCIP_BilinTerm::coef, consdataFindQuadVarTerm(), consdataSortQuadVarTerms(), FALSE, getGradientMaxElement(), LapackDsyev(), MAX, MIN, NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPallocBlockMemoryArray, SCIPallocBufferArray, SCIPconsGetData(), SCIPconsGetName(), SCIPdebugMessage, SCIPdebugPrintf, SCIPfreeBlockMemoryArray, SCIPfreeBufferArray, SCIPisIpoptAvailableIpopt(), SCIPisNegative(), SCIPisPositive(), SCIPisRelEQ(), SCIPisZero(), SCIPvarGetName(), sqrt(), TRUE, SCIP_BilinTerm::var1, and SCIP_BilinTerm::var2.

Referenced by checkCurvature(), and SCIP_DECL_CONSINITSOL().

static SCIP_Real getGradientMaxElement	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SOL *	sol
	)

static

gets maximal absolute value in gradient of quadratic function

Parameters

scip	SCIP data structure
cons	constraint
sol	solution or NULL if LP solution should be used

Definition at line 4911 of file cons_quadratic.c.

References computeViolation(), NULL, REALABS, SCIP_Real, SCIP_STAGE_SOLVING, SCIPconsGetData(), SCIPgetSolVal(), SCIPgetStage(), and SCIPisInfinity().

Referenced by checkFactorable(), and computeViolation().

static SCIP_RETCODE computeViolation	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_CONS *	cons,
		SCIP_SOL *	sol
	)

static

computes activity and violation of a constraint

Parameters

scip	SCIP data structure
conshdlr	constraint handler
cons	constraint
sol	solution or NULL if LP solution should be used

Definition at line 4963 of file cons_quadratic.c.

References computeViolations(), getGradientMaxElement(), MAX, MIN, NULL, REALABS, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_Real, SCIPABORT, SCIPconsGetData(), SCIPconshdlrGetData(), SCIPerrorMessage, SCIPgetSolVal(), SCIPinfinity(), SCIPisFeasGE(), SCIPisFeasLE(), SCIPisInfinity(), SCIPvarGetLbLocal(), and SCIPvarGetUbLocal().

Referenced by computeViolations(), getGradientMaxElement(), proposeFeasibleSolution(), SCIP_DECL_CONSCHECK(), SCIPgetActivityQuadratic(), SCIPgetFeasibilityQuadratic(), and SCIPgetViolationQuadratic().

static SCIP_RETCODE computeViolations	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_CONS **	conss,
		int	nconss,
		SCIP_SOL *	sol,
		SCIP_CONS **	maxviolcon
	)

static

computes violation of a set of constraints

Parameters

scip	SCIP data structure
conshdlr	constraint handler
conss	constraints
nconss	number of constraints
sol	solution or NULL if LP solution should be used
maxviolcon	buffer to store constraint with largest violation, or NULL if solution is feasible

Definition at line 5126 of file cons_quadratic.c.

References computeViolation(), generateCutFactorableDo(), MAX, NULL, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPconsGetData(), SCIPfeastol(), and SCIPisGT().

Referenced by computeViolation(), SCIP_DECL_CONSENFOLP(), SCIP_DECL_CONSENFOPS(), SCIP_DECL_CONSSEPALP(), and SCIP_DECL_CONSSEPASOL().

static void generateCutFactorableDo	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Real *	ref,
		SCIP_Real	multleft,
		SCIP_Real *	coefleft,
		SCIP_Real	multright,
		SCIP_Real *	coefright,
		SCIP_Real	rightminactivity,
		SCIP_Real	rightmaxactivity,
		SCIP_Real	rhs,
		SCIP_Real *	cutcoef,
		SCIP_Real *	cutrhs,
		SCIP_Bool *	islocal,
		SCIP_Bool *	success,
		char *	name
	)

static

tries to compute cut for multleft * <coefleft, x'> * multright <= rhs / (multright * <coefright, x'>) where x'=(x,1)

Parameters

scip	SCIP data structure
cons	constraint
ref	reference solution where to generate the cut
multleft	multiplicator on lhs
coefleft	coefficient for factor on lhs
multright	multiplicator on both sides
coefright	coefficient for factor that goes to rhs
rightminactivity	minimal activity of <coefright, x>
rightmaxactivity	maximal activity of <coefright, x>
rhs	denominator on rhs
cutcoef	array to store cut coefficients for quadratic variables
cutrhs	buffer to store cut rhs
islocal	buffer to set to TRUE if local information was used
success	buffer to indicate whether a cut was successfully computed
name	buffer to store name of cut

Definition at line 5171 of file cons_quadratic.c.

References FALSE, generateCutFactorable(), NULL, SCIP_MAXSTRLEN, SCIP_Real, SCIPconsGetData(), SCIPconsGetName(), SCIPgetNLPs(), SCIPisFeasLE(), SCIPisInfinity(), SCIPisZero(), SCIPsnprintf(), and TRUE.

Referenced by computeViolations(), and generateCutFactorable().

static SCIP_RETCODE generateCutFactorable	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SIDETYPE	violside,
		SCIP_Real *	ref,
		SCIP_Real *	cutcoef,
		SCIP_Real *	cutlhs,
		SCIP_Real *	cutrhs,
		SCIP_Bool *	islocal,
		SCIP_Bool *	success,
		char *	name
	)

static

tries to generate a cut if constraint quadratic function is factorable and there are no linear variables (ax+b)(cx+d) <= rhs and cx+d >= 0 -> (ax+b) <= rhs / (cx+d), where the right hand side is concave and can be linearized

Parameters

scip	SCIP data structure
cons	constraint
violside	for which side a cut should be generated
ref	reference solution where to generate the cut
cutcoef	array to store cut coefficients for quadratic variables
cutlhs	buffer to store cut lhs
cutrhs	buffer to store cut rhs
islocal	buffer to set to TRUE if local information was used
success	buffer to indicate whether a cut was successfully computed
name	buffer to store name of cut

Definition at line 5279 of file cons_quadratic.c.

References FALSE, generateCutFactorableDo(), generateCutLTIfindIntersection(), NULL, SCIP_Bool, SCIP_OKAY, SCIP_Real, SCIP_SIDETYPE_RIGHT, SCIPconsGetData(), SCIPinfinity(), SCIPisFeasNegative(), SCIPisFeasPositive(), SCIPisInfinity(), SCIPisZero(), SCIPvarGetLbLocal(), and SCIPvarGetUbLocal().

Referenced by generateCut(), and generateCutFactorableDo().

static SCIP_Bool generateCutLTIfindIntersection	(	SCIP *	scip,
		SCIP_Real	x0,
		SCIP_Real	y0_,
		SCIP_Real	x1,
		SCIP_Real	y1_,
		SCIP_Real	wl,
		SCIP_Real	wu,
		SCIP_Real *	xl,
		SCIP_Real *	yl,
		SCIP_Real *	xu,
		SCIP_Real *	yu
	)

static

Definition at line 5495 of file cons_quadratic.c.

References FALSE, generateCutLTIgenMulCoeff(), NULL, SCIP_Bool, SCIP_INVALID, SCIP_Real, SCIPdebugMessage, SCIPisInfinity(), SCIPisRelEQ(), SCIPisZero(), sqrt(), and TRUE.

Referenced by generateCutFactorable(), and generateCutLTIcomputeCoefs().

static SCIP_Bool generateCutLTIgenMulCoeff	(	SCIP *	scip,
		SCIP_Real	x1,
		SCIP_Real	y1_,
		SCIP_Real	x2,
		SCIP_Real	y2,
		SCIP_Bool	whichuse,
		SCIP_Real *	cx,
		SCIP_Real *	cy,
		SCIP_Real *	cw
	)

static

generate coefficients for a plane through points (x1, y1_, x1*y1) and (x2, y2, x2*y2) such that intersecting it with one of them (the first if whichuse is FALSE, the second otherwise) gives a tangent to the curve x*y = k

Returns TRUE on error and FALSE on success.

Definition at line 5625 of file cons_quadratic.c.

References FALSE, generateCutLTIcomputeCoefs(), NULL, SCIP_Real, SCIPisZero(), and TRUE.

Referenced by generateCutLTIcomputeCoefs(), and generateCutLTIfindIntersection().

static void generateCutLTIcomputeCoefs	(	SCIP *	scip,
		SCIP_Real	xl,
		SCIP_Real	xu,
		SCIP_Real	x0,
		SCIP_Real	yl,
		SCIP_Real	yu,
		SCIP_Real	y0_,
		SCIP_Real	wl,
		SCIP_Real	wu,
		SCIP_Real	w0,
		SCIP_Real *	cx,
		SCIP_Real *	cy,
		SCIP_Real *	cw,
		SCIP_Real *	c0,
		SCIP_Bool *	success
	)

static

computes coefficients of a lifted-tangent inequality for x*y = w

The code is an adaptation of the methods in exprMul-upperHull.cpp in Couenne/stable/0.4 rev773, written by P. Belotti and licensed under Eclipse Public License.

Parameters

scip	SCIP data structure
xl	lower bound on x
xu	upper bound on x
x0	reference point for x
yl	lower bound on y
yu	upper bound on y
y0_	reference point for y
wl	lower bound on w
wu	upper bound on w
w0	reference point for w
cx	buffer where to store cut coefficient for x
cy	buffer where to store cut coefficient for y
cw	buffer where to store cut coefficient for w
c0	buffer where to store cut left-hand-side
success	buffer where to indicate whether cut coefficients were computed

Definition at line 5683 of file cons_quadratic.c.

References FALSE, generateCutLTI(), generateCutLTIfindIntersection(), generateCutLTIgenMulCoeff(), MAX, MIN, NULL, SCIP_Bool, SCIP_INVALID, SCIP_Real, SCIPdebugMessage, SCIPisFeasGE(), SCIPisFeasLE(), SCIPisGE(), SCIPisGT(), SCIPisInfinity(), SCIPisLE(), SCIPisLT(), SCIPisZero(), and TRUE.

Referenced by generateCutLTI(), and generateCutLTIgenMulCoeff().

static SCIP_RETCODE generateCutLTI	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SIDETYPE	violside,
		SCIP_Real *	ref,
		SCIP_SOL *	sol,
		SCIP_Real **	cutcoeflin,
		SCIP_Real *	cutcoefquad,
		SCIP_Real *	cutlhs,
		SCIP_Real *	cutrhs,
		SCIP_Bool *	islocal,
		SCIP_Bool *	success,
		char *	name
	)

static

tries to generate a cut if constraint quadratic function is factorable and there are linear variables

Computes what is called a lifted tangent inequality described in
Belotti, Miller, Namazifar, Lifted inequalities for bounded products of variables, SIAG/OPT Views-and-News 22:1, 2011

Parameters

scip	SCIP data structure
cons	constraint
violside	for which side a cut should be generated
ref	reference solution where to generate the cut
sol	solution that shall be cutoff, NULL for LP solution
cutcoeflin	buffer to store pointer to array with coefficients for linear variables
cutcoefquad	array to store cut coefficients for quadratic variables
cutlhs	buffer to store cut lhs
cutrhs	buffer to store cut rhs
islocal	buffer to set to TRUE if local information was used
success	buffer to indicate whether a cut was successfully computed
name	buffer to store name of cut

Definition at line 6042 of file cons_quadratic.c.

References FALSE, generateCutConvex(), generateCutLTIcomputeCoefs(), NULL, SCIP_CALL, SCIP_LPSOLSTAT_OPTIMAL, SCIP_MAXSTRLEN, SCIP_OKAY, SCIP_Real, SCIP_SIDETYPE_LEFT, SCIPallocBufferArray, SCIPconsGetData(), SCIPconsGetName(), SCIPdebugMessage, SCIPgetLPSolstat(), SCIPgetNLPs(), SCIPgetSolVal(), SCIPinfinity(), SCIPisFeasNegative(), SCIPisFeasPositive(), SCIPisInfinity(), SCIPisRelEQ(), SCIPsnprintf(), SCIPvarGetLbLocal(), SCIPvarGetUbLocal(), and TRUE.

Referenced by generateCut(), and generateCutLTIcomputeCoefs().

static SCIP_RETCODE generateCutConvex	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SIDETYPE	violside,
		SCIP_Real *	ref,
		SCIP_Real *	coef,
		SCIP_Real *	lhs,
		SCIP_Real *	rhs,
		SCIP_Bool *	islocal,
		SCIP_Bool *	success,
		char *	name
	)

static

computes cut coefficients by linearizing a quadratic function

Parameters

scip	SCIP data structure
cons	constraint
violside	side for which to generate cut
ref	reference solution where to generate the cut
coef	array to store cut coefficients w.r.t. quadratic variables
lhs	buffer to store left-hand-side of cut
rhs	buffer to store right-hand-side of cut
islocal	buffer to set to TRUE if local bounds were used
success	buffer to indicate whether a cut was successfully computed
name	buffer to store name for cut

Definition at line 6309 of file cons_quadratic.c.

References BMSclearMemoryArray, SCIP_BilinTerm::coef, generateCutNonConvex(), NULL, SCIP_MAXSTRLEN, SCIP_OKAY, SCIP_Real, SCIP_SIDETYPE_LEFT, SCIP_VARTYPE_CONTINUOUS, SCIPaddBilinLinearization(), SCIPaddSquareLinearization(), SCIPconsGetData(), SCIPconsGetName(), SCIPdebugMessage, SCIPgetNLPs(), SCIPinfinity(), SCIPsnprintf(), SCIPvarGetType(), TRUE, SCIP_BilinTerm::var1, and SCIP_BilinTerm::var2.

Referenced by generateCut(), and generateCutLTI().

static SCIP_RETCODE generateCutNonConvex	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SIDETYPE	violside,
		SCIP_Real *	ref,
		SCIP_Real *	coef,
		SCIP_Real *	lhs,
		SCIP_Real *	rhs,
		SCIP_Bool *	islocal,
		SCIP_Bool *	success,
		char *	name
	)

static

computes cut coefficients for a nonconvex quadratic function

Parameters

scip	SCIP data structure
cons	constraint
violside	side for which to generate cut
ref	reference solution where to generate the cut
coef	array to store cut coefficients w.r.t. quadratic variables
lhs	buffer to store left-hand-side of cut
rhs	buffer to store right-hand-side of cut
islocal	buffer to set to TRUE if local bounds were used
success	buffer to indicate whether a cut was successfully computed
name	buffer to store name for cut

Definition at line 6399 of file cons_quadratic.c.

References BMSclearMemoryArray, SCIP_BilinTerm::coef, generateCut(), NULL, SCIP_MAXSTRLEN, SCIP_OKAY, SCIP_Real, SCIP_SIDETYPE_LEFT, SCIP_SIDETYPE_RIGHT, SCIP_VARTYPE_CONTINUOUS, SCIPaddBilinMcCormick(), SCIPaddSquareLinearization(), SCIPaddSquareSecant(), SCIPconsGetData(), SCIPconsGetName(), SCIPdebugMessage, SCIPgetNLPs(), SCIPinfinity(), SCIPsnprintf(), SCIPvarGetLbLocal(), SCIPvarGetType(), SCIPvarGetUbLocal(), TRUE, SCIP_BilinTerm::var1, and SCIP_BilinTerm::var2.

Referenced by generateCut(), and generateCutConvex().

static SCIP_RETCODE generateCut	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_CONS *	cons,
		SCIP_Real *	ref,
		SCIP_SOL *	sol,
		SCIP_SIDETYPE	violside,
		SCIP_ROW **	row,
		SCIP_Real *	efficacy,
		SCIP_Bool	checkcurvmultivar,
		SCIP_Real	minefficacy
	)

static

generates a cut based on linearization (if convex) or McCormick (if nonconvex) in a given reference point

Parameters

scip	SCIP data structure
conshdlr	constraint handler
cons	constraint
ref	reference solution where to generate the cut
sol	point that we aim to separate, or NULL for LP solution
violside	for which side a cut should be generated
row	storage for cut
efficacy	buffer to store efficacy of row in reference solution, or NULL if not of interest
checkcurvmultivar	are we allowed to check the curvature of a multivariate quadratic function, if not done yet
minefficacy	minimal required efficacy (violation scaled by maximal absolute coefficient)

Definition at line 6507 of file cons_quadratic.c.

References checkCurvature(), computeInteriorPoint(), FALSE, generateCutConvex(), generateCutFactorable(), generateCutLTI(), generateCutNonConvex(), MAX, NULL, REALABS, SCIP_Bool, SCIP_CALL, SCIP_INVALIDDATA, SCIP_LPSOLSTAT_OPTIMAL, SCIP_MAXSTRLEN, SCIP_OKAY, SCIP_Real, SCIP_SIDETYPE_LEFT, SCIP_SIDETYPE_RIGHT, SCIP_STAGE_SOLVING, SCIP_VARSTATUS_LOOSE, SCIPABORT, SCIPaddVarsToRow(), SCIPallocBufferArray, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconshdlrGetData(), SCIPconsIsLocal(), SCIPcreateEmptyRowCons(), SCIPdebugMessage, SCIPerrorMessage, SCIPfreeBufferArray, SCIPgetDepth(), SCIPgetLPSolstat(), SCIPgetSolVal(), SCIPgetStage(), SCIPinfinity(), SCIPisEQ(), SCIPisFeasNegative(), SCIPisFeasPositive(), SCIPisGT(), SCIPisInfinity(), SCIPisIntegral(), SCIPisLT(), SCIPround(), SCIProwGetName(), SCIProwGetNNonz(), SCIPvarGetLbGlobal(), SCIPvarGetLbLocal(), SCIPvarGetName(), SCIPvarGetStatus(), SCIPvarGetUbGlobal(), SCIPvarGetUbLocal(), and TRUE.

Referenced by generateCutNonConvex(), generateCutSol(), generateCutUnboundedLP(), and SCIP_DECL_CONSINITLP().

static SCIP_RETCODE computeInteriorPoint	(	SCIP *	scip,
		SCIP_CONS *	cons,
		char	method,
		SCIP_Bool *	success
	)

static

computes an interior point for the quadratic part of the convex constraint

There are different methods for computing the interior point

'a'ny: solves min 0, f(x) <= rhs, x in bounds
'm'ost interior: solves min f(x), x in bounds

Parameters

scip	SCIP data structure
cons	constraint
method	method for computing interior point ('a' any point, 'm'ost interior)
success	buffer to store if an interior point was found

Definition at line 6878 of file cons_quadratic.c.

References SCIP_QuadElement::coef, computeGauge(), createNlRow(), FALSE, SCIP_QuadElement::idx1, SCIP_QuadElement::idx2, INTERIOR_EPS, NULL, SCIP_CALL, SCIP_INVALIDDATA, SCIP_MAXSTRLEN, SCIP_NLPPAR_VERBLEVEL, SCIP_NLPSOLSTAT_FEASIBLE, SCIP_NLPSOLSTAT_GLOBINFEASIBLE, SCIP_NLPSOLSTAT_GLOBOPT, SCIP_NLPSOLSTAT_LOCINFEASIBLE, SCIP_NLPSOLSTAT_LOCOPT, SCIP_NLPSOLSTAT_UNBOUNDED, SCIP_NLPSOLSTAT_UNKNOWN, SCIP_NLPTERMSTAT_OKAY, SCIP_OKAY, SCIP_Real, SCIPABORT, SCIPallocBufferArray, SCIPallocClearMemoryArray, SCIPallocMemoryArray, SCIPconsGetData(), SCIPconsGetName(), SCIPdebugMessage, SCIPerrorMessage, SCIPfreeBufferArrayNull, SCIPgetNlpis(), SCIPgetNNlpis(), SCIPgetProbName(), SCIPinfinity(), SCIPinfoMessage(), SCIPisFeasZero(), SCIPisGE(), SCIPisInfinity(), SCIPisLE(), SCIPnlpiAddConstraints(), SCIPnlpiAddVars(), SCIPnlpiCreateProblem(), SCIPnlpiFreeProblem(), SCIPnlpiGetSolstat(), SCIPnlpiGetSolution(), SCIPnlpiGetTermstat(), SCIPnlpiSetIntPar(), SCIPnlpiSetObjective(), SCIPnlpiSolve(), SCIPnlrowGetNQuadElems(), SCIPnlrowGetQuadElems(), SCIPnlrowGetQuadVars(), SCIPprintCons(), SCIPsnprintf(), SCIPvarGetLbGlobal(), SCIPvarGetLbLocal(), SCIPvarGetName(), SCIPvarGetUbGlobal(), SCIPvarGetUbLocal(), and TRUE.

Referenced by computeGauge(), and generateCut().

static SCIP_RETCODE computeGauge	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_CONS *	cons
	)

static

compute gauge function of the set $S - s_0$ where $S = \{ x : f(x) \le c \}$ and $s_0 \in \mathring S$ .

Here, $ f(x) $ is a purely quadratic (i.e, all $x$ variables appear in a bilinear or quadratic term). Explicitly, $f(x) = \pm x^T A x \pm b^T x$ depending whether $A$ is positive semidefinite (+) or negative semidefinite (-). The constant $c$ is rhs - maximum activity of the purely linear part of the constraint if $A \succeq 0$ and minimum activity - lhs if $A \preceq 0$ . This is computed only at INITSOL.

The method does:

compute interior point
compute gauge function

Parameters

scip	SCIP data structure
conshdlr	constraint handler
cons	constraint

Definition at line 7253 of file cons_quadratic.c.

References SCIP_QuadVarTerm::adjbilin, SCIP_BilinTerm::coef, computeInteriorPoint(), evaluateGauge(), FALSE, SCIP_QuadVarTerm::lincoef, SCIP_QuadVarTerm::nadjbilin, NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPallocClearMemoryArray, SCIPconsGetData(), SCIPconsGetName(), SCIPconshdlrGetData(), SCIPdebugMessage, SCIPisInfinity(), SCIPvarGetName(), SCIP_QuadVarTerm::sqrcoef, TRUE, SCIP_QuadVarTerm::var, SCIP_BilinTerm::var1, and SCIP_BilinTerm::var2.

Referenced by computeInteriorPoint(), and SCIP_DECL_CONSINITSOL().

static SCIP_RETCODE evaluateGauge	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_CONS *	cons,
		SCIP_SOL *	refsol,
		SCIP_Real *	gaugeval,
		SCIP_Bool *	success
	)

static

evaluates gauge function of the set $S - s_0$ where $S = \{ x : f(x) \le c \}$ and $s_0 \in \mathring S$ .

$S = \{ x : f(x) \le c \}$ at $sol - s_0$ ; see computeGauge() for more details

Parameters

scip	SCIP data structure
conshdlr	constraint handler
cons	constraint
refsol	reference point where to generate cut, or NULL if sol should be used
gaugeval	buffer to store the value of the gauge function
success	buffer to store if evaluation was successful

Definition at line 7390 of file cons_quadratic.c.

References computeReferencePointGauge(), FALSE, NULL, SCIP_Bool, SCIP_OKAY, SCIP_Real, SCIPconsGetData(), SCIPconsGetName(), SCIPdebugMessage, SCIPgetSolVal(), SCIPisGE(), SCIPisInfinity(), SCIPisLE(), SCIPisNegative(), SCIPisPositive(), SCIPisZero(), SCIPvarGetLbLocal(), SCIPvarGetName(), SCIPvarGetUbLocal(), sqrt(), and TRUE.

Referenced by computeGauge(), and computeReferencePointGauge().

static SCIP_RETCODE computeReferencePointGauge	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_CONS *	cons,
		SCIP_SOL *	refsol,
		SCIP_Real **	ref,
		SCIP_Bool *	success
	)

static

compute reference point suggested by gauge function

Parameters

scip	SCIP data structure
conshdlr	constraint handler
cons	constraint
refsol	reference point where to compute gauge, or NULL if LP solution should be used
ref	pointer to store reference point
success	buffer to store whether we succeeded computing reference point

Definition at line 7563 of file cons_quadratic.c.

References evaluateGauge(), FALSE, GAUGESCALE, generateCutSol(), MAX, MIN, NULL, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPconsGetData(), SCIPconsGetName(), SCIPdebugMessage, SCIPgetSolVal(), SCIPisFeasLE(), SCIPisInfinity(), SCIPvarGetLbLocal(), SCIPvarGetName(), and SCIPvarGetUbLocal().

Referenced by evaluateGauge(), and generateCutSol().

static SCIP_RETCODE generateCutSol	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_CONS *	cons,
		SCIP_SOL *	sol,
		SCIP_SOL *	refsol,
		SCIP_SIDETYPE	violside,
		SCIP_ROW **	row,
		SCIP_Real *	efficacy,
		SCIP_Bool	checkcurvmultivar,
		SCIP_Real	minefficacy
	)

static

generates a cut based on linearization (if convex) or McCormick (if nonconvex) in a solution

Parameters

scip	SCIP data structure
conshdlr	constraint handler
cons	constraint
sol	solution where to generate cut, or NULL if LP solution should be used
refsol	reference point where to generate cut, or NULL if sol should be used
violside	for which side a cut should be generated
row	storage for cut
efficacy	buffer to store efficacy of row in reference solution, or NULL if not of interest
checkcurvmultivar	are we allowed to check the curvature of a multivariate quadratic function, if not done yet
minefficacy	minimal required efficacy (violation scaled by maximal absolute coefficient)

Definition at line 7669 of file cons_quadratic.c.

References computeReferencePointGauge(), FALSE, generateCut(), generateCutUnboundedLP(), MAX, MIN, NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIP_SIDETYPE_LEFT, SCIP_SIDETYPE_RIGHT, SCIPallocBufferArray, SCIPconsGetData(), SCIPconshdlrGetData(), SCIPdebugMessage, SCIPfreeBufferArray, SCIPgetSolVal(), SCIPisCutApplicable(), SCIPisGT(), SCIPisInfinity(), SCIPvarGetLbLocal(), and SCIPvarGetUbLocal().

Referenced by addLinearizationCuts(), computeReferencePointGauge(), generateCutUnboundedLP(), and separatePoint().

static SCIP_RETCODE generateCutUnboundedLP	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_CONS *	cons,
		SCIP_SIDETYPE	violside,
		SCIP_ROW **	row,
		SCIP_Real *	rowrayprod,
		SCIP_Bool	checkcurvmultivar
	)

static

tries to find a cut that intersects with an unbounded ray of the LP

For convex functions, we do this by linearizing in the feasible solution of the LPI. For nonconvex functions, we just call generateCutSol with the unbounded solution as reference point.

Parameters

scip	SCIP data structure
conshdlr	constraint handler
cons	constraint
violside	for which side a cut should be generated
row	storage for cut
rowrayprod	buffer to store product of ray with row coefficients, or NULL if not of interest
checkcurvmultivar	are we allowed to check the curvature of a multivariate quadratic function, if not done yet

Definition at line 7756 of file cons_quadratic.c.

References checkCurvature(), SCIP_BilinTerm::coef, FALSE, generateCut(), generateCutSol(), NULL, REALABS, SCIP_CALL, SCIP_LPSOLSTAT_UNBOUNDEDRAY, SCIP_OKAY, SCIP_Real, SCIP_SIDETYPE_LEFT, SCIP_SIDETYPE_RIGHT, SCIPallocBufferArray, SCIPcolGetVar(), SCIPconsGetData(), SCIPconsGetName(), SCIPdebugMessage, SCIPfreeBufferArray, SCIPgetLPSolstat(), SCIPgetPrimalRayVal(), SCIPhasPrimalRay(), SCIPinfinity(), SCIPisNegative(), SCIPisPositive(), SCIPisZero(), SCIProwGetCols(), SCIProwGetNNonz(), SCIProwGetVals(), separatePoint(), SCIP_BilinTerm::var1, and SCIP_BilinTerm::var2.

Referenced by generateCutSol(), and separatePoint().

static SCIP_RETCODE separatePoint	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_CONS **	conss,
		int	nconss,
		int	nusefulconss,
		SCIP_SOL *	sol,
		SCIP_Real	minefficacy,
		SCIP_Bool	inenforcement,
		SCIP_RESULT *	result,
		SCIP_Real *	bestefficacy
	)

static

tries to separate solution or LP solution by a linear cut

assumes that constraint violations have been computed

Parameters

scip	SCIP data structure
conshdlr	quadratic constraints handler
conss	constraints
nconss	number of constraints
nusefulconss	number of constraints that seem to be useful
sol	solution to separate, or NULL if LP solution should be used
minefficacy	minimal efficacy of a cut if it should be added to the LP
inenforcement	whether we are in constraint enforcement
result	result of separation
bestefficacy	buffer to store best efficacy of a cut that was added to the LP, if found; or NULL if not of interest

Definition at line 7903 of file cons_quadratic.c.

References addLinearizationCuts(), FALSE, generateCutSol(), generateCutUnboundedLP(), MAX, MIN, NULL, REALABS, SCIP_Bool, SCIP_CALL, SCIP_CUTOFF, SCIP_DIDNOTFIND, SCIP_FEASIBLE, SCIP_INVALIDDATA, SCIP_LPSOLSTAT_UNBOUNDEDRAY, SCIP_OKAY, SCIP_Real, SCIP_SEPARATED, SCIP_SIDETYPE_LEFT, SCIP_SIDETYPE_RIGHT, SCIPABORT, SCIPaddCut(), SCIPconsGetData(), SCIPconsGetName(), SCIPconshdlrGetData(), SCIPdebugMessage, SCIPepsilon(), SCIPerrorMessage, SCIPfeastol(), SCIPgetLPSolstat(), SCIPgetRelaxFeastolFactor(), SCIPgetRowMaxCoef(), SCIPisCutApplicable(), SCIPisGT(), SCIPisInfinity(), SCIPisNegative(), SCIPisPositive(), SCIPmarkRowNotRemovableLocal(), SCIPreleaseRow(), SCIPresetConsAge(), SCIProwGetLhs(), and SCIProwGetRhs().

Referenced by generateCutUnboundedLP(), SCIP_DECL_CONSENFOLP(), SCIP_DECL_CONSSEPALP(), and SCIP_DECL_CONSSEPASOL().

static SCIP_RETCODE addLinearizationCuts	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_CONS **	conss,
		int	nconss,
		SCIP_SOL *	ref,
		SCIP_Bool *	separatedlpsol,
		SCIP_Real	minefficacy
	)

static

adds linearizations cuts for convex constraints w.r.t. a given reference point to cutpool and sepastore

If separatedlpsol is not NULL, then a cut that separates the LP solution is added to the sepastore and is forced to enter the LP.
If separatedlpsol is not NULL, but cut does not separate the LP solution, then it is added to the cutpool only.
If separatedlpsol is NULL, then cut is added to cutpool only.

Parameters

scip	SCIP data structure
conshdlr	quadratic constraints handler
conss	constraints
nconss	number of constraints
ref	reference point where to linearize, or NULL for LP solution
separatedlpsol	buffer to store whether a cut that separates the current LP solution was found and added to LP, or NULL if adding to cutpool only
minefficacy	minimal efficacy of a cut when checking for separation of LP solution

Definition at line 8075 of file cons_quadratic.c.

References checkCurvature(), FALSE, generateCutSol(), MAX, MIN, NULL, REALABS, SCIP_Bool, SCIP_CALL, SCIP_DECL_EVENTEXEC(), SCIP_INVALIDDATA, SCIP_OKAY, SCIP_Real, SCIP_SIDETYPE_LEFT, SCIP_SIDETYPE_RIGHT, SCIPABORT, SCIPaddCut(), SCIPaddPoolCut(), SCIPconsGetData(), SCIPconshdlrGetData(), SCIPconsIsEnabled(), SCIPconsIsLocal(), SCIPdebugMessage, SCIPerrorMessage, SCIPgetRowLPFeasibility(), SCIPgetRowMaxCoef(), SCIPinfinity(), SCIPisInfinity(), SCIPreleaseRow(), SCIProwGetLhs(), SCIProwGetName(), SCIProwGetRhs(), SCIProwIsLocal(), and TRUE.

Referenced by SCIP_DECL_CONSSEPALP(), SCIP_DECL_EVENTEXEC(), and separatePoint().

static SCIP_DECL_EVENTEXEC ( processNewSolutionEvent )

static

processes the event that a new primal solution has been found

Definition at line 8195 of file cons_quadratic.c.

References addLinearizationCuts(), NULL, registerBranchingCandidatesGap(), SCIP_CALL, SCIP_EVENTTYPE_SOLFOUND, SCIP_OKAY, SCIPconshdlrGetConss(), SCIPconshdlrGetData(), SCIPconshdlrGetNConss(), SCIPdebugMessage, SCIPeventGetSol(), SCIPeventGetType(), SCIPheurGetName(), and SCIPsolGetHeur().

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

static

registers branching candidates according to convexification gap rule

That is, computes for every nonconvex term the gap between the terms value in the LP solution and the value of the underestimator as it would be (and maybe has been) constructed by the separation routines of this constraint handler. Then it registers all variables occurring in each term with the computed gap. If variables appear in more than one term, they are registered several times.

Parameters

scip	SCIP data structure
conshdlr	constraint handler
conss	constraints to check
nconss	number of constraints to check
nnotify	counter for number of notifications performed

Definition at line 8247 of file cons_quadratic.c.

References MAX, MIN, NULL, REALABS, registerBranchingCandidatesViolation(), SCIP_Bool, SCIP_CALL, SCIP_INVALID, SCIP_OKAY, SCIP_Real, SCIPaddExternBranchCand(), SCIPconsGetData(), SCIPconsGetName(), SCIPdebugMessage, SCIPfeastol(), SCIPgetSolVal(), SCIPinfinity(), SCIPisFeasNegative(), SCIPisGE(), SCIPisGT(), SCIPisInfinity(), SCIPisLE(), SCIPisLT(), SCIPisNegative(), SCIPisRelEQ(), SCIPvarGetLbLocal(), SCIPvarGetName(), SCIPvarGetUbLocal(), SCIPvarIsBinary(), SCIPvarIsIntegral(), and sqrt().

Referenced by registerBranchingCandidates(), and SCIP_DECL_EVENTEXEC().

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

static

registers branching candidates according to constraint violation rule

That is, registers all variables appearing in nonconvex terms^1 with a score that is the violation of the constraint. This is the same rule as is applied in cons_nonlinear and other nonlinear constraint handlers.

1) We mean all quadratic variables that appear either in a nonconvex square term or in a bilinear term, if the constraint itself is nonconvex. (and this under the assumption that the rhs is violated; for violated lhs, swap terms)

Parameters

scip	SCIP data structure
conshdlr	constraint handler
conss	constraints to check
nconss	number of constraints to check
nnotify	counter for number of notifications performed

Definition at line 8461 of file cons_quadratic.c.

References MAX, SCIP_QuadVarTerm::nadjbilin, NULL, registerBranchingCandidatesCentrality(), SCIP_CALL, SCIP_INVALID, SCIP_OKAY, SCIP_Real, SCIPaddExternBranchCand(), SCIPconsGetData(), SCIPconsGetName(), SCIPdebugMessage, SCIPfeastol(), SCIPgetSolVal(), SCIPisGE(), SCIPisGT(), SCIPisLE(), SCIPisRelEQ(), SCIPvarGetLbLocal(), SCIPvarGetName(), SCIPvarGetUbLocal(), SCIP_QuadVarTerm::sqrcoef, and SCIP_QuadVarTerm::var.

Referenced by registerBranchingCandidates(), and registerBranchingCandidatesGap().

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

static

registers branching candidates according to centrality rule

That is, registers all variables appearing in nonconvex terms^1 with a score that is given by the distance of the variable value from its bounds. This rule should not make sense, as the distance to the bounds is also (often) considered by the branching rule later on.

1) We mean all quadratic variables that appear either in a nonconvex square term or in a bilinear term, if the constraint itself is nonconvex. (and this under the assumption that the rhs is violated; for violated lhs, swap terms)

Parameters

scip	SCIP data structure
conshdlr	constraint handler
conss	constraints to check
nconss	number of constraints to check
nnotify	counter for number of notifications performed

Definition at line 8545 of file cons_quadratic.c.

References MAX, MIN, SCIP_QuadVarTerm::nadjbilin, NULL, registerBranchingCandidates(), SCIP_CALL, SCIP_INVALID, SCIP_OKAY, SCIP_Real, SCIPaddExternBranchCand(), SCIPconsGetData(), SCIPconsGetName(), SCIPdebugMessage, SCIPfeastol(), SCIPgetSolVal(), SCIPisEQ(), SCIPisGT(), SCIPisInfinity(), SCIPisRelEQ(), SCIPvarGetLbLocal(), SCIPvarGetName(), SCIPvarGetUbLocal(), SCIP_QuadVarTerm::sqrcoef, and SCIP_QuadVarTerm::var.

Referenced by registerBranchingCandidates(), and registerBranchingCandidatesViolation().

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

static

registers branching candidates

Parameters

scip	SCIP data structure
conshdlr	constraint handler
conss	constraints to check
nconss	number of constraints to check
nnotify	counter for number of notifications performed

Definition at line 8632 of file cons_quadratic.c.

References NULL, registerBranchingCandidatesCentrality(), registerBranchingCandidatesGap(), registerBranchingCandidatesViolation(), registerLargeLPValueVariableForBranching(), SCIP_CALL, SCIP_ERROR, SCIP_OKAY, SCIPABORT, SCIPconshdlrGetData(), and SCIPerrorMessage.

Referenced by registerBranchingCandidatesCentrality(), and SCIP_DECL_CONSENFOLP().

static SCIP_RETCODE registerLargeLPValueVariableForBranching	(	SCIP *	scip,
		SCIP_CONS **	conss,
		int	nconss,
		SCIP_VAR **	brvar
	)

static

registers a quadratic variable from a violated constraint as branching candidate that has a large absolute value in the LP relaxation

Parameters

scip	SCIP data structure
conss	constraints
nconss	number of constraints
brvar	buffer to store branching variable

Definition at line 8671 of file cons_quadratic.c.

References NULL, replaceByLinearConstraints(), SCIP_CALL, SCIP_INVALID, SCIP_OKAY, SCIP_Real, SCIPaddExternBranchCand(), SCIPconsGetData(), SCIPfeastol(), SCIPgetSolVal(), SCIPisGT(), SCIPisRelEQ(), SCIPvarGetLbLocal(), and SCIPvarGetUbLocal().

Referenced by registerBranchingCandidates(), and SCIP_DECL_CONSENFOLP().

static SCIP_RETCODE replaceByLinearConstraints	(	SCIP *	scip,
		SCIP_CONS **	conss,
		int	nconss,
		SCIP_Bool *	addedcons,
		SCIP_Bool *	reduceddom,
		SCIP_Bool *	infeasible
	)

static

replaces violated quadratic constraints where all quadratic variables are fixed by linear constraints

Parameters

scip	SCIP data structure
conss	constraints
nconss	number of constraints
addedcons	buffer to store whether a linear constraint was added
reduceddom	whether a domain has been reduced
infeasible	whether we detected infeasibility

Definition at line 8723 of file cons_quadratic.c.

References FALSE, NULL, propagateBoundsTightenVarLb(), SCIP_Bool, SCIP_CALL, SCIP_INFEASIBLE, SCIP_LPSOLSTAT_OPTIMAL, SCIP_OKAY, SCIP_Real, SCIPaddConsLocal(), SCIPcheckCons(), SCIPconsGetData(), SCIPconsGetName(), SCIPconsIsChecked(), SCIPconsIsDynamic(), SCIPconsIsEnforced(), SCIPconsIsInitial(), SCIPconsIsModifiable(), SCIPconsIsPropagated(), SCIPconsIsRemovable(), SCIPconsIsSeparated(), SCIPconsIsStickingAtNode(), SCIPcreateConsLinear(), SCIPdebugMessage, SCIPdebugPrintCons, SCIPdelConsLocal(), SCIPfeastol(), SCIPgetLPSolstat(), SCIPinfinity(), SCIPisGT(), SCIPisInfinity(), SCIPisRelEQ(), SCIPisZero(), SCIPreleaseCons(), SCIPtightenVarLb(), SCIPtightenVarUb(), SCIPvarGetLbLocal(), SCIPvarGetName(), SCIPvarGetUbLocal(), and TRUE.

Referenced by registerLargeLPValueVariableForBranching(), and SCIP_DECL_CONSENFOLP().

static SCIP_RETCODE propagateBoundsTightenVarLb	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Real	intervalinfty,
		SCIP_VAR *	var,
		SCIP_Real	bnd,
		SCIP_RESULT *	result,
		int *	nchgbds
	)

static

tightens a lower bound on a variable and checks the result

Parameters

scip	SCIP data structure
cons	constraint where we currently propagate
intervalinfty	infinity value used in interval operations
var	variable which domain we might reduce
bnd	new lower bound for variable
result	result to update if there was a tightening or cutoff
nchgbds	counter to increase if a bound was tightened

Definition at line 8902 of file cons_quadratic.c.

References FALSE, NULL, propagateBoundsTightenVarUb(), SCIP_Bool, SCIP_CALL, SCIP_CUTOFF, SCIP_DIDNOTFIND, SCIP_OKAY, SCIP_REDUCEDDOM, SCIPadjustedVarLb(), SCIPconsGetName(), SCIPdebugMessage, SCIPinProbing(), SCIPisHugeValue(), SCIPisInfinity(), SCIPisLE(), SCIPresetConsAge(), SCIPtightenVarLb(), SCIPvarGetLbLocal(), and SCIPvarGetName().

Referenced by propagateBoundsBilinearTerm(), propagateBoundsCons(), propagateBoundsQuadVar(), and replaceByLinearConstraints().

static SCIP_RETCODE propagateBoundsTightenVarUb	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Real	intervalinfty,
		SCIP_VAR *	var,
		SCIP_Real	bnd,
		SCIP_RESULT *	result,
		int *	nchgbds
	)

static

tightens an upper bound on a variable and checks the result

Parameters

scip	SCIP data structure
cons	constraint where we currently propagate
intervalinfty	infinity value used in interval operations
var	variable which domain we might reduce
bnd	new upper bound for variable
result	result to update if there was a tightening or cutoff
nchgbds	counter to increase if a bound was tightened

Definition at line 8963 of file cons_quadratic.c.

References FALSE, NULL, propagateBoundsQuadVar(), SCIP_Bool, SCIP_CALL, SCIP_CUTOFF, SCIP_DIDNOTFIND, SCIP_OKAY, SCIP_REDUCEDDOM, SCIPadjustedVarUb(), SCIPconsGetName(), SCIPdebugMessage, SCIPinProbing(), SCIPisGE(), SCIPisHugeValue(), SCIPisInfinity(), SCIPresetConsAge(), SCIPtightenVarUb(), SCIPvarGetName(), and SCIPvarGetUbLocal().

Referenced by propagateBoundsBilinearTerm(), propagateBoundsCons(), propagateBoundsQuadVar(), and propagateBoundsTightenVarLb().

static SCIP_RETCODE propagateBoundsQuadVar	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Real	intervalinfty,
		SCIP_VAR *	var,
		SCIP_Real	a,
		SCIP_INTERVAL	b,
		SCIP_INTERVAL	rhs,
		SCIP_RESULT *	result,
		int *	nchgbds
	)

static

solves a quadratic equation $a x^2 + b x \in rhs$ (with b an interval) and reduces bounds on x or deduces infeasibility if possible

Parameters

scip	SCIP data structure
cons	constraint where we currently propagate
intervalinfty	infinity value used in interval operations
var	variable which bounds with might tighten
a	coefficient in square term
b	coefficient in linear term
rhs	right hand side of quadratic equation
result	result of propagation
nchgbds	buffer where to add number of tightened bounds

Definition at line 9024 of file cons_quadratic.c.

References MAX, MIN, NULL, propagateBoundsBilinearTerm(), propagateBoundsTightenVarLb(), propagateBoundsTightenVarUb(), SCIP_CALL, SCIP_CUTOFF, SCIP_DIDNOTFIND, SCIP_OKAY, SCIP_Real, SCIP_REDUCEDDOM, SCIPconsGetName(), SCIPdebugMessage, SCIPintervalAddScalar(), SCIPintervalGetInf(), SCIPintervalGetRoundingMode(), SCIPintervalGetSup(), SCIPintervalIsEmpty(), SCIPintervalIsEntire(), SCIPintervalMulScalar(), SCIPintervalQuad(), SCIPintervalQuadUpperBound(), SCIPintervalSet(), SCIPintervalSetBounds(), SCIPintervalSetRoundingMode(), SCIPintervalSetRoundingModeDownwards(), SCIPintervalSetRoundingModeUpwards(), SCIPintervalSolveUnivariateQuadExpression(), SCIPintervalSolveUnivariateQuadExpressionPositive(), SCIPintervalSub(), SCIPisInfinity(), SCIPresetConsAge(), SCIPvarGetLbLocal(), SCIPvarGetName(), and SCIPvarGetUbLocal().

Referenced by propagateBoundsCons(), and propagateBoundsTightenVarUb().

static SCIP_RETCODE propagateBoundsBilinearTerm	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Real	intervalinfty,
		SCIP_VAR *	x,
		SCIP_Real	xsqrcoef,
		SCIP_Real	xlincoef,
		SCIP_VAR *	y,
		SCIP_Real	ysqrcoef,
		SCIP_Real	ylincoef,
		SCIP_Real	bilincoef,
		SCIP_INTERVAL	rhs,
		SCIP_RESULT *	result,
		int *	nchgbds
	)

static

tries to deduce domain reductions for x in xsqrcoef x^2 + xlincoef x + ysqrcoef y^2 + ylincoef y + bilincoef x y \in rhs

Note: Domain reductions for y are not deduced.

Parameters

scip	SCIP data structure
cons	the constraint, where the bilinear term belongs to
intervalinfty	infinity value used in interval operations
x	first variable
xsqrcoef	square coefficient of x
xlincoef	linear coefficient of x
y	second variable
ysqrcoef	square coefficient of y
ylincoef	linear coefficient of y
bilincoef	bilinear coefficient of x*y
rhs	right hand side of quadratic equation
result	pointer to store result of domain propagation
nchgbds	counter to increment if domain reductions are found

Definition at line 9223 of file cons_quadratic.c.

References infty2infty, MAX, MIN, NULL, propagateBoundsGetQuadActivity(), propagateBoundsTightenVarLb(), propagateBoundsTightenVarUb(), SCIP_CALL, SCIP_CUTOFF, SCIP_DIDNOTFIND, SCIP_OKAY, SCIP_REDUCEDDOM, SCIPconsGetName(), SCIPdebugMessage, SCIPinfinity(), SCIPintervalGetInf(), SCIPintervalGetSup(), SCIPintervalIsEmpty(), SCIPintervalIsEntire(), SCIPintervalSetBounds(), SCIPintervalSolveBivariateQuadExpressionAllScalar(), SCIPisInfinity(), SCIPvarGetLbLocal(), SCIPvarGetName(), and SCIPvarGetUbLocal().

Referenced by propagateBoundsCons(), and propagateBoundsQuadVar().

static void propagateBoundsGetQuadActivity	(	SCIP *	scip,
		SCIP_CONSDATA *	consdata,
		SCIP_Real	intervalinfty,
		SCIP_Real *	minquadactivity,
		SCIP_Real *	maxquadactivity,
		int *	minactivityinf,
		int *	maxactivityinf,
		SCIP_INTERVAL *	quadactcontr
	)

static

computes the minimal and maximal activity for the quadratic part in a constraint data

Only sums up terms that contribute finite values. Gives the number of terms that contribute infinite values. Only computes those activities where the corresponding side of the constraint is finite.

Parameters

scip	SCIP data structure
consdata	constraint data
intervalinfty	infinity value used in interval operations
minquadactivity	minimal activity of quadratic variable terms where only terms with finite minimal activity contribute
maxquadactivity	maximal activity of quadratic variable terms where only terms with finite maximal activity contribute
minactivityinf	number of quadratic variables that contribute -infinity to minimal activity
maxactivityinf	number of quadratic variables that contribute +infinity to maximal activity
quadactcontr	contribution of each quadratic variables to quadactivity

Definition at line 9297 of file cons_quadratic.c.

References SCIP_Interval::inf, infty2infty, MAX, MIN, NULL, propagateBoundsCons(), SCIP_Real, SCIPinfinity(), SCIPintervalAdd(), SCIPintervalGetInf(), SCIPintervalGetRoundingMode(), SCIPintervalGetSup(), SCIPintervalIsEmpty(), SCIPintervalMulScalar(), SCIPintervalQuadUpperBound(), SCIPintervalSet(), SCIPintervalSetBounds(), SCIPintervalSetRoundingMode(), SCIPintervalSetRoundingModeDownwards(), SCIPintervalSetRoundingModeUpwards(), SCIPisInfinity(), SCIPvarGetLbLocal(), SCIPvarGetUbLocal(), sqrt(), and SCIP_Interval::sup.

Referenced by propagateBoundsBilinearTerm(), and propagateBoundsCons().

static SCIP_RETCODE propagateBoundsCons	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_CONS *	cons,
		SCIP_RESULT *	result,
		int *	nchgbds,
		SCIP_Bool *	redundant
	)

static

propagates bounds on a quadratic constraint

Parameters

scip	SCIP data structure
conshdlr	constraint handler
cons	constraint to process
result	pointer to store the result of the propagation call
nchgbds	buffer where to add the the number of changed bounds
redundant	buffer where to store whether constraint has been found to be redundant

Definition at line 9432 of file cons_quadratic.c.

References consdataFindQuadVarTerm(), consdataSortQuadVarTerms(), consdataUpdateLinearActivity(), FALSE, SCIP_Interval::inf, infty2infty, MAX, MIN, NULL, propagateBounds(), propagateBoundsBilinearTerm(), propagateBoundsGetQuadActivity(), propagateBoundsQuadVar(), propagateBoundsTightenVarLb(), propagateBoundsTightenVarUb(), SCIP_CALL, SCIP_CUTOFF, SCIP_DIDNOTFIND, SCIP_DIDNOTRUN, SCIP_INVALID, SCIP_OKAY, SCIP_Real, SCIPallocBufferArray, SCIPconsGetData(), SCIPconsGetName(), SCIPdebugMessage, SCIPepsilon(), SCIPfreeBufferArrayNull, SCIPinfinity(), SCIPintervalAdd(), SCIPintervalGetInf(), SCIPintervalGetRoundingMode(), SCIPintervalGetSup(), SCIPintervalIsEmpty(), SCIPintervalIsEntire(), SCIPintervalIsSubsetEQ(), SCIPintervalMulInf(), SCIPintervalMulScalar(), SCIPintervalMulSup(), SCIPintervalNegateReal(), SCIPintervalSet(), SCIPintervalSetBounds(), SCIPintervalSetRoundingMode(), SCIPintervalSetRoundingModeDownwards(), SCIPintervalSetRoundingModeUpwards(), SCIPintervalSub(), SCIPisEQ(), SCIPisFeasGT(), SCIPisFeasLT(), SCIPisInfinity(), SCIPvarGetLbLocal(), SCIPvarGetUbLocal(), SCIP_Interval::sup, and TRUE.

Referenced by propagateBounds(), propagateBoundsGetQuadActivity(), and SCIP_DECL_CONSPRESOL().

static SCIP_RETCODE propagateBounds	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_CONS **	conss,
		int	nconss,
		SCIP_RESULT *	result,
		int *	nchgbds
	)

static

calls domain propagation for a set of constraints

Parameters

scip	SCIP data structure
conshdlr	constraint handler
conss	constraints to process
nconss	number of constraints
result	pointer to store the result of the propagation calls
nchgbds	buffer where to add the the number of changed bounds

Definition at line 9966 of file cons_quadratic.c.

References consdataFindUnlockedLinearVar(), FALSE, NULL, propagateBoundsCons(), SCIP_Bool, SCIP_CALL, SCIP_CUTOFF, SCIP_DIDNOTFIND, SCIP_DIDNOTRUN, SCIP_OKAY, SCIP_STAGE_PRESOLVING, SCIP_STAGE_SOLVING, SCIPconsGetName(), SCIPconshdlrGetData(), SCIPconsIsEnabled(), SCIPdebugMessage, SCIPdelConsLocal(), SCIPgetStage(), and TRUE.

Referenced by propagateBoundsCons(), SCIP_DECL_CONSENFOLP(), SCIP_DECL_CONSENFOPS(), and SCIP_DECL_CONSPROP().

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

static

checks for a linear variable that can be increase or decreased without harming feasibility

Parameters

scip	SCIP data structure
consdata	constraint data

Definition at line 10035 of file cons_quadratic.c.

References proposeFeasibleSolution(), SCIPdebugMessage, SCIPisInfinity(), SCIPvarGetName(), SCIPvarGetNLocksDown(), and SCIPvarGetObj().

Referenced by propagateBounds(), SCIP_DECL_CONSCHECK(), and SCIP_DECL_CONSINITSOL().

static SCIP_RETCODE proposeFeasibleSolution	(	SCIP *	scip,
		SCIP_CONSHDLR *	conshdlr,
		SCIP_CONS **	conss,
		int	nconss,
		SCIP_SOL *	sol,
		SCIP_Bool *	success
	)

static

Given a solution where every quadratic constraint is either feasible or can be made feasible by moving a linear variable, construct the corresponding feasible solution and pass it to the trysol heuristic.

The method assumes that this is always possible and that not all constraints are feasible already.

Parameters

scip	SCIP data structure
conshdlr	constraint handler
conss	constraints to process
nconss	number of constraints
sol	solution to process
success	buffer to store whether we succeeded to construct a solution that satisfies all provided constraints

Definition at line 10100 of file cons_quadratic.c.

References computeViolation(), FALSE, MAX, MIN, NULL, SCIP_CALL, SCIP_DECL_NONLINCONSUPGD(), SCIP_OKAY, SCIP_Real, SCIP_STAGE_INITPRESOLVE, SCIP_STAGE_SOLVED, SCIPceil(), SCIPconsGetData(), SCIPconshdlrGetData(), SCIPcreateLPSol(), SCIPcreateSolCopy(), SCIPdebugMessage, SCIPfeastol(), SCIPfloor(), SCIPfreeSol(), SCIPgetSolTransObj(), SCIPgetSolVal(), SCIPgetStage(), SCIPgetUpperbound(), SCIPheurGetName(), SCIPheurPassSolTrySol(), SCIPincSolVal(), SCIPisGT(), SCIPisInfinity(), SCIPisNegative(), SCIPisPositive(), SCIPisSumLT(), SCIPisZero(), SCIPsolGetHeur(), SCIPunlinkSol(), SCIPvarGetLbGlobal(), SCIPvarGetName(), SCIPvarGetUbGlobal(), SCIPvarIsIntegral(), and TRUE.

Referenced by consdataFindUnlockedLinearVar(), and SCIP_DECL_CONSCHECK().

static SCIP_DECL_NONLINCONSUPGD ( nonlinconsUpgdQuadratic )

static

tries to upgrade a nonlinear constraint into a quadratic constraint

Definition at line 10255 of file cons_quadratic.c.

Referenced by proposeFeasibleSolution().

static SCIP_DECL_CONSHDLRCOPY ( conshdlrCopyQuadratic )

static

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

Definition at line 10435 of file cons_quadratic.c.

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

Referenced by SCIP_DECL_NONLINCONSUPGD().

static SCIP_DECL_CONSFREE ( consFreeQuadratic )

static

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

Definition at line 10451 of file cons_quadratic.c.

References NULL, SCIP_DECL_CONSINIT(), SCIP_OKAY, SCIPconshdlrGetData(), SCIPfreeMemory, and SCIPfreeMemoryArrayNull.

Referenced by SCIP_DECL_CONSHDLRCOPY().

static SCIP_DECL_CONSINIT ( consInitQuadratic )

static

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

Definition at line 10476 of file cons_quadratic.c.

References NULL, SCIP_DECL_CONSEXIT(), SCIP_OKAY, SCIPconshdlrGetData(), and SCIPfindHeur().

Referenced by SCIP_DECL_CONSFREE().

static SCIP_DECL_CONSEXIT ( consExitQuadratic )

static

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

Definition at line 10495 of file cons_quadratic.c.

References NULL, SCIP_DECL_CONSEXITPRE(), SCIP_DECL_CONSINITPRE, SCIP_OKAY, and SCIPconshdlrGetData().

Referenced by SCIP_DECL_CONSINIT().

static SCIP_DECL_CONSEXITPRE ( consExitpreQuadratic )

static

presolving initialization method of constraint handler (called when presolving is about to begin) presolving deinitialization method of constraint handler (called after presolving has been finished)

Definition at line 10533 of file cons_quadratic.c.

References mergeAndCleanBilinearTerms(), mergeAndCleanLinearVars(), mergeAndCleanQuadVarTerms(), NULL, removeFixedVariables(), SCIP_CALL, SCIP_DECL_CONSINITSOL(), SCIP_OKAY, SCIPconsGetData(), SCIPconsIsAdded(), SCIPenableNLP(), and SCIPvarIsActive().

Referenced by SCIP_DECL_CONSEXIT().

static SCIP_DECL_CONSINITSOL ( consInitsolQuadratic )

static

solving process initialization method of constraint handler (called when branch and bound process is about to begin)

Note: Also called from consEnableQuadratic during solving stage.

Definition at line 10587 of file cons_quadratic.c.

References checkCurvature(), checkFactorable(), computeGauge(), consdataFindQuadVarTerm(), consdataFindUnlockedLinearVar(), consdataSortQuadVarTerms(), CONSHDLR_NAME, createNlRow(), FALSE, MAX, MIN, NULL, REALABS, SCIP_CALL, SCIP_DECL_CONSEXITSOL(), SCIP_EVENTTYPE_SOLFOUND, SCIP_OKAY, SCIP_STAGE_INITSOLVE, SCIP_VERBLEVEL_HIGH, SCIPaddNlRow(), SCIPallocBlockMemoryArray, SCIPcatchEvent(), SCIPconsGetData(), SCIPconshdlrGetData(), SCIPconsIsEnabled(), SCIPfindEventhdlr(), SCIPgetStage(), SCIPgetSubscipDepth(), SCIPinfinity(), SCIPisInfinity(), SCIPisInRestart(), SCIPisIpoptAvailableIpopt(), SCIPisNLPConstructed(), and SCIPverbMessage().

Referenced by SCIP_DECL_CONSEXITPRE().

static SCIP_DECL_CONSEXITSOL ( consExitsolQuadratic )

static

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

Note: Also called from consDisableQuadratic during solving stage.

Definition at line 10705 of file cons_quadratic.c.

References CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_DECL_CONSDELETE(), SCIP_EVENTTYPE_SOLFOUND, SCIP_OKAY, SCIP_STAGE_EXITSOLVE, SCIPconsGetData(), SCIPconshdlrGetData(), SCIPdropEvent(), SCIPfindEventhdlr(), SCIPfreeBlockMemoryArrayNull, SCIPfreeMemoryArrayNull, SCIPgetStage(), and SCIPreleaseNlRow().

Referenced by SCIP_DECL_CONSINITSOL().

static SCIP_DECL_CONSDELETE ( consDeleteQuadratic )

static

frees specific constraint data

Definition at line 10763 of file cons_quadratic.c.

References consdataFree(), NULL, SCIP_CALL, SCIP_DECL_CONSTRANS(), SCIP_OKAY, and SCIPconsGetData().

Referenced by SCIP_DECL_CONSEXITSOL().

static SCIP_DECL_CONSTRANS ( consTransQuadratic )

static

transforms constraint data into data belonging to the transformed problem

Definition at line 10780 of file cons_quadratic.c.

References consdataCreate(), FALSE, NULL, SCIP_CALL, SCIP_DECL_CONSINITLP(), SCIP_OKAY, SCIPcaptureVar(), SCIPconsGetData(), SCIPconsGetName(), SCIPconsIsChecked(), SCIPconsIsDynamic(), SCIPconsIsEnforced(), SCIPconsIsInitial(), SCIPconsIsLocal(), SCIPconsIsModifiable(), SCIPconsIsPropagated(), SCIPconsIsRemovable(), SCIPconsIsSeparated(), SCIPconsIsStickingAtNode(), SCIPcreateCons(), SCIPdebugMessage, SCIPdebugPrintCons, SCIPgetTransformedVar(), and SCIPvarCompare().

Referenced by SCIP_DECL_CONSDELETE().

static SCIP_DECL_CONSINITLP ( consInitlpQuadratic )

static

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

Definition at line 10837 of file cons_quadratic.c.

References checkCurvature(), FALSE, generateCut(), INITLPMAXVARVAL, MAX, MIN, NULL, REALABS, SCIP_Bool, SCIP_BOUNDTYPE_LOWER, SCIP_CALL, SCIP_DECL_CONSSEPALP(), SCIP_OKAY, SCIP_Real, SCIP_SIDETYPE_LEFT, SCIP_SIDETYPE_RIGHT, SCIPaddCut(), SCIPaddVarsToRow(), SCIPallocBufferArray, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconshdlrGetData(), SCIPconsIsLocal(), SCIPcreateEmptyRowCons(), SCIPdebug, SCIPdebugMessage, SCIPfreeBufferArray, SCIPinfinity(), SCIPisInfinity(), SCIPprintRow(), SCIPreleaseRow(), SCIProwGetName(), SCIPvarGetBestBoundLocal(), SCIPvarGetBestBoundType(), SCIPvarGetLbGlobal(), SCIPvarGetUbGlobal(), SCIPvarGetWorstBoundLocal(), and TRUE.

Referenced by SCIP_DECL_CONSTRANS().

static SCIP_DECL_CONSSEPALP ( consSepalpQuadratic )

static

separation method of constraint handler for LP solutions

Definition at line 11050 of file cons_quadratic.c.

References addLinearizationCuts(), checkCurvature(), computeViolations(), FALSE, NULL, SCIP_Bool, SCIP_CALL, SCIP_CUTOFF, SCIP_DECL_CONSSEPASOL(), SCIP_DIDNOTFIND, SCIP_LPSOLSTAT_OPTIMAL, SCIP_LPSOLSTAT_UNBOUNDEDRAY, SCIP_NLPSOLSTAT_FEASIBLE, SCIP_NLPSOLSTAT_GLOBINFEASIBLE, SCIP_NLPSOLSTAT_UNKNOWN, SCIP_OKAY, SCIP_SEPARATED, SCIPaddLinearConsToNlpHeurSubNlp(), SCIPconsGetData(), SCIPconshdlrGetData(), SCIPcreateNLPSol(), SCIPdebugMessage, SCIPfeastol(), SCIPfreeSol(), SCIPgetDepth(), SCIPgetLPSolstat(), SCIPgetNBinVars(), SCIPgetNContVars(), SCIPgetNIntVars(), SCIPgetNLPFracVars(), SCIPgetNLPSolstat(), SCIPgetNNlpis(), SCIPgetNVars(), SCIPgetSolOrigObj(), SCIPheurPassSolTrySol(), SCIPisGT(), SCIPisNLPConstructed(), SCIPsetNLPInitialGuessSol(), SCIPsolveNLP(), separatePoint(), and TRUE.

Referenced by SCIP_DECL_CONSINITLP().

static SCIP_DECL_CONSSEPASOL ( consSepasolQuadratic )

static

separation method of constraint handler for arbitrary primal solutions

Definition at line 11195 of file cons_quadratic.c.

References computeViolations(), FALSE, NULL, SCIP_CALL, SCIP_DECL_CONSENFOLP(), SCIP_DIDNOTFIND, SCIP_OKAY, SCIPconshdlrGetData(), and separatePoint().

Referenced by SCIP_DECL_CONSSEPALP().

static SCIP_DECL_CONSENFOLP ( consEnfolpQuadratic )

static

constraint enforcing method of constraint handler for LP solutions

Definition at line 11222 of file cons_quadratic.c.

References computeViolations(), MAX, MIN, NULL, propagateBounds(), registerBranchingCandidates(), registerLargeLPValueVariableForBranching(), replaceByLinearConstraints(), SCIP_Bool, SCIP_BRANCHED, SCIP_CALL, SCIP_CONSADDED, SCIP_CUTOFF, SCIP_DECL_CONSENFOPS(), SCIP_FEASIBLE, SCIP_INFEASIBLE, SCIP_OKAY, SCIP_Real, SCIP_REDUCEDDOM, SCIP_SEPARATED, SCIP_VERBLEVEL_HIGH, SCIPconsGetData(), SCIPconsGetName(), SCIPconshdlrGetData(), SCIPcreateChild(), SCIPdebugMessage, SCIPepsilon(), SCIPfeastol(), SCIPgetCurrentNode(), SCIPgetRelaxFeastolFactor(), SCIPgetSolVal(), SCIPisGT(), SCIPisInfinity(), SCIPisStopped(), SCIPnodeGetEstimate(), SCIPvarGetName(), SCIPverbMessage(), SCIPwarningMessage(), separatePoint(), and TRUE.

Referenced by SCIP_DECL_CONSSEPASOL().

static SCIP_DECL_CONSENFOPS ( consEnfopsQuadratic )

static

constraint enforcing method of constraint handler for pseudo solutions

Definition at line 11409 of file cons_quadratic.c.

References computeViolations(), MAX, NULL, propagateBounds(), SCIP_CALL, SCIP_CUTOFF, SCIP_DECL_CONSPROP(), SCIP_FEASIBLE, SCIP_INFEASIBLE, SCIP_INVALID, SCIP_OKAY, SCIP_REDUCEDDOM, SCIP_SOLVELP, SCIPaddExternBranchCand(), SCIPconsGetData(), SCIPconsGetName(), SCIPdebugMessage, SCIPfeastol(), SCIPisGT(), SCIPisRelEQ(), SCIPvarGetLbLocal(), and SCIPvarGetUbLocal().

Referenced by SCIP_DECL_CONSENFOLP().

static SCIP_DECL_CONSPROP ( consPropQuadratic )

static

domain propagation method of constraint handler

Definition at line 11489 of file cons_quadratic.c.

References NULL, propagateBounds(), SCIP_CALL, SCIP_DECL_CONSPRESOL(), and SCIP_OKAY.

Referenced by SCIP_DECL_CONSENFOPS().

static SCIP_DECL_CONSPRESOL ( consPresolQuadratic )

static

presolving method of constraint handler

Definition at line 11506 of file cons_quadratic.c.

References FALSE, mergeAndCleanBilinearTerms(), mergeAndCleanLinearVars(), mergeAndCleanQuadVarTerms(), NULL, presolveDisaggregate(), presolveSolve(), presolveTryAddAND(), presolveTryAddLinearReform(), presolveUpgrade(), propagateBoundsCons(), removeFixedVariables(), SCIP_Bool, SCIP_CALL, SCIP_CUTOFF, SCIP_DECL_CONSLOCK(), SCIP_DIDNOTFIND, SCIP_OKAY, SCIP_PRESOLTIMING_EXHAUSTIVE, SCIP_PRESOLTIMING_FAST, SCIP_REDUCEDDOM, SCIP_SUCCESS, SCIP_VARTYPE_CONTINUOUS, SCIP_VARTYPE_IMPLINT, SCIPchgVarType(), SCIPconsGetData(), SCIPconsGetName(), SCIPconshdlrGetData(), SCIPdebugMessage, SCIPdebugPrintCons, SCIPdelCons(), SCIPisEQ(), SCIPisFeasNegative(), SCIPisFeasPositive(), SCIPisInfinity(), SCIPisIntegral(), SCIPisPresolveFinished(), SCIPvarGetName(), SCIPvarGetType(), and TRUE.

Referenced by SCIP_DECL_CONSPROP().

static SCIP_DECL_CONSLOCK ( consLockQuadratic )

static

variable rounding lock method of constraint handler

Definition at line 11786 of file cons_quadratic.c.

References NULL, SCIP_Bool, SCIP_CALL, SCIP_DECL_CONSENABLE(), SCIP_OKAY, SCIPaddVarLocks(), SCIPconsGetData(), and SCIPisInfinity().

Referenced by SCIP_DECL_CONSPRESOL().

static SCIP_DECL_CONSENABLE ( consEnableQuadratic )

static

constraint enabling notification method of constraint handler

Definition at line 11839 of file cons_quadratic.c.

References catchVarEvents(), mergeAndCleanBilinearTerms(), mergeAndCleanLinearVars(), mergeAndCleanQuadVarTerms(), NULL, SCIP_CALL, SCIP_DECL_CONSDISABLE(), SCIP_OKAY, SCIP_STAGE_EXITPRESOLVE, SCIP_STAGE_SOLVING, SCIPconsGetName(), SCIPconshdlrGetData(), SCIPconsIsActive(), SCIPconsIsTransformed(), SCIPdebugMessage, and SCIPgetStage().

Referenced by SCIP_DECL_CONSLOCK().

static SCIP_DECL_CONSDISABLE ( consDisableQuadratic )

static

constraint disabling notification method of constraint handler

Definition at line 11876 of file cons_quadratic.c.

References dropVarEvents(), FALSE, NULL, SCIP_CALL, SCIP_DECL_CONSPRINT(), SCIP_OKAY, SCIP_STAGE_SOLVING, SCIPconsGetName(), SCIPconshdlrGetData(), SCIPconsIsTransformed(), SCIPdebugMessage, and SCIPgetStage().

Referenced by SCIP_DECL_CONSENABLE().

static SCIP_DECL_CONSPRINT ( consPrintQuadratic )

static

constraint display method of constraint handler

Definition at line 11904 of file cons_quadratic.c.

References NULL, SCIP_CALL, SCIP_DECL_CONSCHECK(), SCIP_OKAY, SCIP_Real, SCIPallocBufferArray, SCIPconsGetData(), SCIPfreeBufferArray, SCIPfreeBufferArrayNull, SCIPinfoMessage(), SCIPisEQ(), SCIPisInfinity(), SCIPwriteVarsPolynomial(), and TRUE.

Referenced by SCIP_DECL_CONSDISABLE().

static SCIP_DECL_CONSCHECK ( consCheckQuadratic )

static

feasibility check method of constraint handler for integral solutions

Definition at line 12037 of file cons_quadratic.c.

References computeViolation(), consdataFindUnlockedLinearVar(), FALSE, NULL, proposeFeasibleSolution(), REALABS, SCIP_Bool, SCIP_CALL, SCIP_DECL_CONSCOPY(), SCIP_FEASIBLE, SCIP_INFEASIBLE, SCIP_OKAY, SCIP_Real, SCIP_STAGE_INITSOLVE, SCIP_STAGE_SOLVING, SCIP_STAGE_TRANSFORMED, SCIPconsGetData(), SCIPconshdlrGetData(), SCIPfeastol(), SCIPgetStage(), SCIPinfoMessage(), SCIPisGT(), SCIPisInfinity(), SCIPprintCons(), and SCIPupdateStartpointHeurSubNlp().

Referenced by SCIP_DECL_CONSPRINT().

static SCIP_DECL_CONSCOPY ( consCopyQuadratic )

static

constraint copying method of constraint handler

Definition at line 12138 of file cons_quadratic.c.

References SCIP_QuadVarTerm::adjbilin, SCIP_BilinTerm::coef, SCIP_QuadVarTerm::eventdata, FALSE, SCIP_QuadVarTerm::lincoef, SCIP_QuadVarTerm::nadjbilin, NULL, SCIP_CALL, SCIP_DECL_CONSPARSE(), SCIP_OKAY, SCIPallocBufferArray, SCIPconsGetData(), SCIPconsGetName(), SCIPcreateConsQuadratic2(), SCIPfreeBufferArrayNull, SCIPgetVarCopy(), SCIP_QuadVarTerm::sqrcoef, TRUE, SCIP_QuadVarTerm::var, SCIP_BilinTerm::var1, and SCIP_BilinTerm::var2.

Referenced by SCIP_DECL_CONSCHECK().

static SCIP_DECL_CONSPARSE ( consParseQuadratic )

static

constraint parsing method of constraint handler

Definition at line 12251 of file cons_quadratic.c.

References FALSE, NULL, SCIP_CALL, SCIP_DECL_CONSGETVARS(), SCIP_OKAY, SCIP_Real, SCIPaddBilinTermQuadratic(), SCIPaddConstantQuadratic(), SCIPaddLinearVarQuadratic(), SCIPaddQuadVarQuadratic(), SCIPcreateConsQuadratic(), SCIPerrorMessage, SCIPfindQuadVarTermQuadratic(), SCIPfreeParseVarsPolynomialData(), SCIPinfinity(), SCIPisInfinity(), SCIPparseVarsPolynomial(), SCIPreleaseCons(), and SCIPstrToRealValue().

Referenced by SCIP_DECL_CONSCOPY().

static SCIP_DECL_CONSGETVARS ( consGetVarsQuadratic )

static

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

Definition at line 12444 of file cons_quadratic.c.

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

Referenced by SCIP_DECL_CONSPARSE().

static SCIP_DECL_CONSGETNVARS ( consGetNVarsQuadratic )

static

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

Definition at line 12475 of file cons_quadratic.c.

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

Referenced by SCIP_DECL_CONSGETVARS().

SCIP_RETCODE SCIPincludeConshdlrQuadratic ( SCIP * scip )

creates the handler for quadratic constraints and includes it in SCIP

Parameters

scip	SCIP data structure

Definition at line 12497 of file cons_quadratic.c.

References BMSclearMemory, CONSHDLR_CHECKPRIORITY, CONSHDLR_DELAYPROP, CONSHDLR_DELAYSEPA, CONSHDLR_DESC, CONSHDLR_EAGERFREQ, CONSHDLR_ENFOPRIORITY, CONSHDLR_MAXPREROUNDS, CONSHDLR_NAME, CONSHDLR_NEEDSCONS, CONSHDLR_PRESOLTIMING, CONSHDLR_PROP_TIMING, CONSHDLR_PROPFREQ, CONSHDLR_SEPAFREQ, CONSHDLR_SEPAPRIORITY, FALSE, NONLINCONSUPGD_PRIORITY, NULL, SCIP_CALL, SCIP_OKAY, SCIPaddBoolParam(), SCIPaddCharParam(), SCIPaddIntParam(), SCIPaddRealParam(), SCIPallocMemory, SCIPincludeConshdlrBasic(), SCIPincludeEventhdlrBasic(), SCIPincludeNonlinconsUpgrade(), SCIPincludeQuadconsUpgrade(), SCIPinfinity(), SCIPsetConshdlrCopy(), SCIPsetConshdlrDelete(), SCIPsetConshdlrDisable(), SCIPsetConshdlrEnable(), SCIPsetConshdlrExit(), SCIPsetConshdlrExitpre(), SCIPsetConshdlrExitsol(), SCIPsetConshdlrFree(), SCIPsetConshdlrGetNVars(), SCIPsetConshdlrGetVars(), SCIPsetConshdlrInit(), SCIPsetConshdlrInitlp(), SCIPsetConshdlrInitsol(), SCIPsetConshdlrParse(), SCIPsetConshdlrPresol(), SCIPsetConshdlrPrint(), SCIPsetConshdlrProp(), SCIPsetConshdlrSepa(), SCIPsetConshdlrTrans(), and TRUE.

Referenced by SCIP_DECL_CONSGETNVARS(), SCIP_DECL_CONSHDLRCOPY(), and SCIPincludeDefaultPlugins().

SCIP_RETCODE SCIPincludeQuadconsUpgrade	(	SCIP *	scip,
		SCIP_DECL_QUADCONSUPGD((*quadconsupgd))	,
		int	priority,
		SCIP_Bool	active,
		const char *	conshdlrname
	)

includes a quadratic constraint update method into the quadratic constraint handler

Parameters

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

Definition at line 12639 of file cons_quadratic.c.

References SCIP_QuadConsUpgrade::active, CONSHDLR_NAME, conshdlrdataHasUpgrade(), FALSE, NULL, paramname, SCIP_QuadConsUpgrade::priority, SCIP_CALL, SCIP_MAXSTRLEN, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIPaddBoolParam(), SCIPallocMemory, SCIPcalcMemGrowSize(), SCIPconshdlrGetData(), SCIPcreateConsQuadratic(), SCIPerrorMessage, SCIPfindConshdlr(), SCIPreallocMemoryArray, and SCIPsnprintf().

Referenced by SCIPincludeConshdlrAbspower(), SCIPincludeConshdlrBivariate(), SCIPincludeConshdlrBounddisjunction(), SCIPincludeConshdlrQuadratic(), and SCIPincludeConshdlrSOC().

SCIP_RETCODE SCIPcreateConsQuadratic	(	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 constraint.

The constraint should be given in the form

$\ell \leq \sum_{i=1}^n b_i x_i + \sum_{j=1}^m a_j y_j z_j \leq u,$

where $x_i = y_j = z_k$ is possible.

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 (n)
linvars	array with variables in linear part (x_i)
lincoefs	array with coefficients of variables in linear part (b_i)
nquadterms	number of quadratic terms (m)
quadvars1	array with first variables in quadratic terms (y_j)
quadvars2	array with second variables in quadratic terms (z_j)
quadcoefs	array with coefficients of quadratic terms (a_j)
lhs	left hand side of quadratic equation (ell)
rhs	right hand side of quadratic equation (u)
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 12715 of file cons_quadratic.c.

References addBilinearTerm(), addLinearCoef(), addQuadVarTerm(), consdataCreateEmpty(), consdataEnsureBilinSize(), consdataEnsureLinearVarsSize(), CONSHDLR_NAME, FALSE, NULL, SCIP_CALL, SCIP_OKAY, SCIP_PLUGINNOTFOUND, SCIP_Real, SCIPblkmem(), SCIPcalcHashtableSize(), SCIPcreateCons(), SCIPcreateConsBasicQuadratic(), SCIPdebugMessage, SCIPdebugPrintCons, SCIPerrorMessage, SCIPfindConshdlr(), SCIPhashmapCreate(), SCIPhashmapExists(), SCIPhashmapFree(), SCIPhashmapGetImage(), SCIPhashmapInsert(), and SCIPisZero().

Referenced by createQuadraticCons(), readConstraints(), readObjective(), readQCMatrix(), readQMatrix(), readQuadraticCoefs(), SCIP_DECL_CONSPARSE(), SCIP_DECL_NONLINCONSUPGD(), SCIP_DECL_QUADCONSUPGD(), SCIPcreateConsBasicQuadratic(), SCIPcreateConsIndicator(), SCIPcreateConsIndicatorLinCons(), and SCIPincludeQuadconsUpgrade().

SCIP_RETCODE SCIPcreateConsBasicQuadratic	(	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 constraint with all its flags set to their default values.

The constraint should be given in the form

$\ell \leq \sum_{i=1}^n b_i x_i + \sum_{j=1}^m a_j y_j z_j \leq u,$

where $x_i = y_j = z_k$ is possible.

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 (n)
linvars	array with variables in linear part (x_i)
lincoefs	array with coefficients of variables in linear part (b_i)
nquadterms	number of quadratic terms (m)
quadvars1	array with first variables in quadratic terms (y_j)
quadvars2	array with second variables in quadratic terms (z_j)
quadcoefs	array with coefficients of quadratic terms (a_j)
lhs	left hand side of quadratic equation (ell)
rhs	right hand side of quadratic equation (u)

Definition at line 12889 of file cons_quadratic.c.

References FALSE, SCIP_CALL, SCIP_OKAY, SCIPcreateConsQuadratic(), SCIPcreateConsQuadratic2(), and TRUE.

Referenced by SCIPcreateConsQuadratic().

SCIP_RETCODE SCIPcreateConsQuadratic2	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nlinvars,
		SCIP_VAR **	linvars,
		SCIP_Real *	lincoefs,
		int	nquadvarterms,
		SCIP_QUADVARTERM *	quadvarterms,
		int	nbilinterms,
		SCIP_BILINTERM *	bilinterms,
		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 constraint.

The constraint should be given in the form

$\ell \leq \sum_{i=1}^n b_i x_i + \sum_{j=1}^m (a_j y_j^2 + b_j y_j) + \sum_{k=1}^p c_k v_k w_k \leq u.$

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 (n)
linvars	array with variables in linear part (x_i)
lincoefs	array with coefficients of variables in linear part (b_i)
nquadvarterms	number of quadratic terms (m)
quadvarterms	quadratic variable terms
nbilinterms	number of bilinear terms (p)
bilinterms	bilinear terms
lhs	constraint left hand side (ell)
rhs	constraint right hand side (u)
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 dynamic?
removable	should the constraint be removed from the LP due to aging or cleanup?

Definition at line 12920 of file cons_quadratic.c.

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

Referenced by presolveDisaggregate(), presolveRemoveFixedVariables(), SCIP_DECL_CONSCOPY(), SCIP_DECL_QUADCONSUPGD(), SCIPcreateConsBasicQuadratic(), and SCIPcreateConsBasicQuadratic2().

SCIP_RETCODE SCIPcreateConsBasicQuadratic2	(	SCIP *	scip,
		SCIP_CONS **	cons,
		const char *	name,
		int	nlinvars,
		SCIP_VAR **	linvars,
		SCIP_Real *	lincoefs,
		int	nquadvarterms,
		SCIP_QUADVARTERM *	quadvarterms,
		int	nbilinterms,
		SCIP_BILINTERM *	bilinterms,
		SCIP_Real	lhs,
		SCIP_Real	rhs
	)

creates and captures a quadratic constraint in its most basic version, i.e., all constraint flags are set to their default values.

The constraint should be given in the form

$\ell \leq \sum_{i=1}^n b_i x_i + \sum_{j=1}^m (a_j y_j^2 + b_j y_j) + \sum_{k=1}^p c_k v_k w_k \leq u.$

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 (n)
linvars	array with variables in linear part (x_i)
lincoefs	array with coefficients of variables in linear part (b_i)
nquadvarterms	number of quadratic terms (m)
quadvarterms	quadratic variable terms
nbilinterms	number of bilinear terms (p)
bilinterms	bilinear terms
lhs	constraint left hand side (ell)
rhs	constraint right hand side (u)

Definition at line 12982 of file cons_quadratic.c.

References FALSE, SCIP_CALL, SCIP_OKAY, SCIPaddConstantQuadratic(), SCIPcreateConsQuadratic2(), and TRUE.

Referenced by SCIPcreateConsQuadratic2().

void SCIPaddConstantQuadratic	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_Real	constant
	)

Adds a constant to the constraint function, that is, subtracts a constant from both sides

Parameters

scip	SCIP data structure
cons	constraint
constant	constant to subtract from both sides

Definition at line 13006 of file cons_quadratic.c.

References NULL, REALABS, SCIP_STAGE_SOLVING, SCIPABORT, SCIPaddLinearVarQuadratic(), SCIPconsGetData(), SCIPconsIsEnabled(), SCIPerrorMessage, SCIPgetStage(), SCIPisEQ(), and SCIPisInfinity().

Referenced by SCIP_DECL_CONSPARSE(), SCIP_DECL_NONLINCONSUPGD(), and SCIPcreateConsBasicQuadratic2().

SCIP_RETCODE SCIPaddLinearVarQuadratic	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var,
		SCIP_Real	coef
	)

Adds a linear variable with coefficient to a quadratic constraint.

Parameters

scip	SCIP data structure
cons	constraint
var	variable
coef	coefficient of variable

Definition at line 13042 of file cons_quadratic.c.

References addLinearCoef(), NULL, REALABS, SCIP_CALL, SCIP_INVALIDCALL, SCIP_OKAY, SCIP_STAGE_SOLVING, SCIPaddQuadVarQuadratic(), SCIPconsIsEnabled(), SCIPerrorMessage, SCIPgetStage(), and SCIPisInfinity().

Referenced by presolveDisaggregate(), readObjective(), SCIP_DECL_CONSPARSE(), SCIP_DECL_QUADCONSUPGD(), and SCIPaddConstantQuadratic().

SCIP_RETCODE SCIPaddQuadVarQuadratic	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var,
		SCIP_Real	lincoef,
		SCIP_Real	sqrcoef
	)

Adds a quadratic variable with linear and square coefficient to a quadratic constraint.

Parameters

scip	SCIP data structure
cons	constraint
var	variable
lincoef	linear coefficient of variable
sqrcoef	square coefficient of variable

Definition at line 13067 of file cons_quadratic.c.

References addQuadVarTerm(), NULL, REALABS, SCIP_CALL, SCIP_INVALIDCALL, SCIP_OKAY, SCIP_STAGE_SOLVING, SCIPaddQuadVarLinearCoefQuadratic(), SCIPconsIsEnabled(), SCIPerrorMessage, SCIPgetStage(), and SCIPisInfinity().

Referenced by presolveDisaggregate(), SCIP_DECL_CONSPARSE(), SCIP_DECL_NONLINCONSUPGD(), SCIP_DECL_QUADCONSUPGD(), and SCIPaddLinearVarQuadratic().

SCIP_RETCODE SCIPaddQuadVarLinearCoefQuadratic	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var,
		SCIP_Real	coef
	)

Adds a linear coefficient for a quadratic variable.

Variable will be added with square coefficient 0.0 if not existing yet.

Parameters

scip	SCIP data structure
cons	constraint
var	variable
coef	value to add to linear coefficient of variable

Definition at line 13097 of file cons_quadratic.c.

References addQuadVarTerm(), consdataFindQuadVarTerm(), FALSE, NULL, REALABS, SCIP_CALL, SCIP_INVALID, SCIP_INVALIDCALL, SCIP_OKAY, SCIP_STAGE_SOLVING, SCIPaddSquareCoefQuadratic(), SCIPconsGetData(), SCIPconsIsEnabled(), SCIPerrorMessage, SCIPgetStage(), SCIPintervalSetEmpty(), SCIPisInfinity(), and SCIPisZero().

Referenced by presolveDisaggregate(), SCIP_DECL_NONLINCONSUPGD(), SCIP_DECL_QUADCONSUPGD(), and SCIPaddQuadVarQuadratic().

SCIP_RETCODE SCIPaddSquareCoefQuadratic	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var,
		SCIP_Real	coef
	)

Adds a square coefficient for a quadratic variable.

Variable will be added with linear coefficient 0.0 if not existing yet.

Parameters

scip	SCIP data structure
cons	constraint
var	variable
coef	value to add to square coefficient of variable

Definition at line 13150 of file cons_quadratic.c.

References addQuadVarTerm(), consdataFindQuadVarTerm(), FALSE, NULL, REALABS, SCIP_CALL, SCIP_INVALID, SCIP_INVALIDCALL, SCIP_OKAY, SCIP_STAGE_SOLVING, SCIPaddBilinTermQuadratic(), SCIPconsGetData(), SCIPconsIsEnabled(), SCIPerrorMessage, SCIPgetStage(), SCIPintervalSetEmpty(), SCIPisInfinity(), and SCIPisZero().

Referenced by SCIP_DECL_NONLINCONSUPGD(), SCIP_DECL_QUADCONSUPGD(), SCIPaddBilinTermQuadratic(), and SCIPaddQuadVarLinearCoefQuadratic().

SCIP_RETCODE SCIPaddBilinTermQuadratic	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var1,
		SCIP_VAR *	var2,
		SCIP_Real	coef
	)

Adds a bilinear term to a quadratic constraint.

Variables will be added with linear and square coefficient 0.0 if not existing yet. If variables are equal, only the square coefficient of the variable is updated.

Parameters

scip	SCIP data structure
cons	constraint
var1	first variable
var2	second variable
coef	coefficient of bilinear term

Definition at line 13207 of file cons_quadratic.c.

References addBilinearTerm(), addQuadVarTerm(), consdataFindQuadVarTerm(), consdataSortQuadVarTerms(), NULL, REALABS, SCIP_CALL, SCIP_INVALIDCALL, SCIP_OKAY, SCIP_STAGE_SOLVING, SCIPaddSquareCoefQuadratic(), SCIPconsGetData(), SCIPconsIsEnabled(), SCIPerrorMessage, SCIPgetNlRowQuadratic(), SCIPgetStage(), and SCIPisInfinity().

Referenced by presolveDisaggregate(), readQuadraticCoefs(), SCIP_DECL_CONSPARSE(), SCIP_DECL_NONLINCONSUPGD(), SCIP_DECL_QUADCONSUPGD(), SCIPaddSquareCoefQuadratic(), and SCIPchgBilinCoefQuadratic().

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

Gets the quadratic constraint as a nonlinear row representation.

Parameters

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

Definition at line 13273 of file cons_quadratic.c.

References createNlRow(), NULL, SCIP_CALL, SCIP_OKAY, SCIPconsGetData(), and SCIPgetNLinearVarsQuadratic().

Referenced by createCoveringProblem(), and SCIPaddBilinTermQuadratic().

int SCIPgetNLinearVarsQuadratic	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

Gets the number of variables in the linear term of a quadratic constraint.

Parameters

scip	SCIP data structure
cons	constraint

Definition at line 13298 of file cons_quadratic.c.

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

Referenced by SCIP_DECL_QUADCONSUPGD(), SCIP_DECL_READERWRITE(), SCIPgetNlRowQuadratic(), SCIPwriteGms(), SCIPwriteLp(), and SCIPwritePip().

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

Gets the variables in the linear part of a quadratic constraint. Length is given by SCIPgetNLinearVarsQuadratic.

Parameters

scip	SCIP data structure
cons	constraint

Definition at line 13312 of file cons_quadratic.c.

References NULL, SCIP_Real, SCIPconsGetData(), and SCIPgetCoefsLinearVarsQuadratic().

Referenced by SCIP_DECL_QUADCONSUPGD(), SCIP_DECL_READERWRITE(), SCIPgetNLinearVarsQuadratic(), SCIPwriteGms(), SCIPwriteLp(), and SCIPwritePip().

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

Gets the coefficients in the linear part of a quadratic constraint. Length is given by SCIPgetNLinearVarsQuadratic.

Parameters

scip	SCIP data structure
cons	constraint

Definition at line 13326 of file cons_quadratic.c.

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

Referenced by SCIP_DECL_QUADCONSUPGD(), SCIP_DECL_READERWRITE(), SCIPgetLinearVarsQuadratic(), SCIPwriteGms(), SCIPwriteLp(), and SCIPwritePip().

int SCIPgetNQuadVarTermsQuadratic	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

Gets the number of quadratic variable terms of a quadratic constraint.

Parameters

scip	SCIP data structure
cons	constraint

Definition at line 13339 of file cons_quadratic.c.

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

Referenced by readNonlinearExprs(), SCIP_DECL_QUADCONSUPGD(), SCIP_DECL_READERWRITE(), SCIPgetCoefsLinearVarsQuadratic(), SCIPwriteGms(), SCIPwriteLp(), and SCIPwritePip().

SCIP_QUADVARTERM* SCIPgetQuadVarTermsQuadratic	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

Gets the quadratic variable terms of a quadratic constraint. Length is given by SCIPgetNQuadVarTermsQuadratic.

Parameters

scip	SCIP data structure
cons	constraint

Definition at line 13353 of file cons_quadratic.c.

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

Referenced by readNonlinearExprs(), SCIP_DECL_QUADCONSUPGD(), SCIP_DECL_READERWRITE(), SCIPgetNQuadVarTermsQuadratic(), SCIPwriteGms(), SCIPwriteLp(), and SCIPwritePip().

SCIP_RETCODE SCIPsortQuadVarTermsQuadratic	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

Ensures that quadratic variable terms are sorted.

Parameters

scip	SCIP data structure
cons	constraint

Definition at line 13365 of file cons_quadratic.c.

References consdataSortQuadVarTerms(), NULL, SCIP_CALL, SCIP_OKAY, SCIPconsGetData(), and SCIPfindQuadVarTermQuadratic().

Referenced by readNonlinearExprs(), SCIP_DECL_QUADCONSUPGD(), and SCIPgetQuadVarTermsQuadratic().

SCIP_RETCODE SCIPfindQuadVarTermQuadratic	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var,
		int *	pos
	)

Finds the position of a quadratic variable term for a given variable.

Note: If the quadratic variable terms have not been sorted before, then a search may reorder the current order of the terms.

Parameters

scip	SCIP data structure
cons	constraint
var	variable to search for
pos	buffer to store position of quadvarterm for var, or -1 if not found

Definition at line 13382 of file cons_quadratic.c.

References consdataFindQuadVarTerm(), NULL, SCIP_CALL, SCIP_OKAY, SCIPconsGetData(), and SCIPgetNBilinTermsQuadratic().

Referenced by readNonlinearExprs(), SCIP_DECL_CONSPARSE(), SCIP_DECL_QUADCONSUPGD(), and SCIPsortQuadVarTermsQuadratic().

int SCIPgetNBilinTermsQuadratic	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

Gets the number of bilinear terms of a quadratic constraint.

Parameters

scip	SCIP data structure
cons	constraint

Definition at line 13400 of file cons_quadratic.c.

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

Referenced by readNonlinearExprs(), SCIP_DECL_QUADCONSUPGD(), SCIP_DECL_READERWRITE(), SCIPfindQuadVarTermQuadratic(), SCIPwriteGms(), SCIPwriteLp(), and SCIPwritePip().

SCIP_BILINTERM* SCIPgetBilinTermsQuadratic	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

Gets the bilinear terms of a quadratic constraint. Length is given by SCIPgetNBilinTermQuadratic.

Parameters

scip	SCIP data structure
cons	constraint

Definition at line 13414 of file cons_quadratic.c.

References NULL, SCIP_Real, SCIPconsGetData(), and SCIPgetLhsQuadratic().

Referenced by readNonlinearExprs(), SCIP_DECL_QUADCONSUPGD(), SCIP_DECL_READERWRITE(), SCIPgetNBilinTermsQuadratic(), SCIPwriteGms(), SCIPwriteLp(), and SCIPwritePip().

SCIP_Real SCIPgetLhsQuadratic	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

Gets the left hand side of a quadratic constraint.

Parameters

scip	SCIP data structure
cons	constraint

Definition at line 13426 of file cons_quadratic.c.

References NULL, SCIP_Real, SCIPconsGetData(), and SCIPgetRhsQuadratic().

Referenced by checkConsnames(), createCoveringProblem(), SCIP_DECL_QUADCONSUPGD(), SCIP_DECL_READERWRITE(), SCIPgetBilinTermsQuadratic(), SCIPwriteGms(), SCIPwriteLp(), and SCIPwritePip().

SCIP_Real SCIPgetRhsQuadratic	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

Gets the right hand side of a quadratic constraint.

Parameters

scip	SCIP data structure
cons	constraint

Definition at line 13438 of file cons_quadratic.c.

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

Referenced by checkConsnames(), createCoveringProblem(), SCIP_DECL_QUADCONSUPGD(), SCIP_DECL_READERWRITE(), SCIPgetLhsQuadratic(), SCIPwriteGms(), SCIPwriteLp(), and SCIPwritePip().

SCIP_RETCODE SCIPcheckCurvatureQuadratic	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

Check the quadratic function of a quadratic constraint for its semi-definiteness, if not done yet.

Parameters

scip	SCIP data structure
cons	constraint

Definition at line 13450 of file cons_quadratic.c.

References checkCurvature(), NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIPisConvexQuadratic(), and TRUE.

Referenced by SCIP_DECL_QUADCONSUPGD(), and SCIPgetRhsQuadratic().

SCIP_Bool SCIPisConvexQuadratic	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

Indicates whether the quadratic function of a quadratic constraint is (known to be) convex.

Parameters

scip	SCIP data structure
cons	constraint

Definition at line 13463 of file cons_quadratic.c.

References checkCurvatureEasy(), FALSE, NULL, SCIP_Bool, SCIPconsGetData(), and SCIPisConcaveQuadratic().

Referenced by createCoveringProblem(), SCIP_DECL_QUADCONSUPGD(), and SCIPcheckCurvatureQuadratic().

SCIP_Bool SCIPisConcaveQuadratic	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

Indicates whether the quadratic function of a quadratic constraint is (known to be) concave.

Parameters

scip	SCIP data structure
cons	constraint

Definition at line 13480 of file cons_quadratic.c.

References checkCurvatureEasy(), FALSE, NULL, SCIP_Bool, SCIPconsGetData(), and SCIPgetViolationQuadratic().

Referenced by createCoveringProblem(), SCIP_DECL_QUADCONSUPGD(), and SCIPisConvexQuadratic().

SCIP_RETCODE SCIPgetViolationQuadratic	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SOL *	sol,
		SCIP_Real *	violation
	)

Computes the violation of a constraint by a solution

Parameters

scip	SCIP data structure
cons	constraint
sol	solution which violation to calculate, or NULL for LP solution
violation	pointer to store violation of constraint

Definition at line 13497 of file cons_quadratic.c.

References computeViolation(), MAX, NULL, SCIP_Bool, SCIP_CALL, SCIP_OKAY, SCIPconsGetData(), SCIPconsGetHdlr(), and SCIPisLinearLocalQuadratic().

Referenced by SCIPisConcaveQuadratic().

SCIP_Bool SCIPisLinearLocalQuadratic	(	SCIP *	scip,
		SCIP_CONS *	cons
	)

Indicates whether the quadratic constraint is local w.r.t. the current local bounds.

That is, checks whether each variable with a square term is fixed and for each bilinear term at least one variable is fixed.

Parameters

scip	SCIP data structure
cons	constraint

Definition at line 13528 of file cons_quadratic.c.

References FALSE, NULL, SCIPaddToNlpiProblemQuadratic(), SCIPconsGetData(), SCIPisRelEQ(), SCIPvarGetLbLocal(), SCIPvarGetUbLocal(), and TRUE.

Referenced by SCIPgetViolationQuadratic().

SCIP_RETCODE SCIPaddToNlpiProblemQuadratic	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_NLPI *	nlpi,
		SCIP_NLPIPROBLEM *	nlpiprob,
		SCIP_HASHMAP *	scipvar2nlpivar,
		SCIP_Bool	names
	)

Adds the constraint to an NLPI problem.

Parameters

scip	SCIP data structure
cons	constraint
nlpi	interface to NLP solver
nlpiprob	NLPI problem where to add constraint
scipvar2nlpivar	mapping from SCIP variables to variable indices in NLPI
names	whether to pass constraint names to NLPI

Definition at line 13574 of file cons_quadratic.c.

References SCIP_QuadElement::coef, SCIP_QuadElement::idx1, SCIP_QuadElement::idx2, MAX, MIN, NULL, SCIP_CALL, SCIP_OKAY, SCIP_Real, SCIPallocBufferArray, SCIPchgLhsQuadratic(), SCIPconsGetData(), SCIPconsGetName(), SCIPfreeBufferArrayNull, SCIPhashmapExists(), SCIPhashmapGetImage(), and SCIPnlpiAddConstraints().

Referenced by SCIPisLinearLocalQuadratic().

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

sets the left hand side of a quadratic constraint

Note: This method may only be called during problem creation stage for an original constraint.

Parameters

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

Definition at line 13709 of file cons_quadratic.c.

References CONSHDLR_NAME, NULL, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_STAGE_PROBLEM, SCIPchgRhsQuadratic(), SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPconsIsOriginal(), SCIPerrorMessage, SCIPgetStage(), SCIPinfinity(), SCIPisInfinity(), and SCIPisLE().

Referenced by SCIPaddToNlpiProblemQuadratic().

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

sets the right hand side of a quadratic constraint

Note: This method may only be called during problem creation stage for an original constraint.

Parameters

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

Definition at line 13754 of file cons_quadratic.c.

References CONSHDLR_NAME, NULL, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_STAGE_PROBLEM, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPconsIsOriginal(), SCIPerrorMessage, SCIPgetFeasibilityQuadratic(), SCIPgetStage(), SCIPinfinity(), SCIPisInfinity(), and SCIPisLE().

Referenced by SCIPchgLhsQuadratic().

SCIP_RETCODE SCIPgetFeasibilityQuadratic	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SOL *	sol,
		SCIP_Real *	feasibility
	)

gets the feasibility of the quadratic constraint in the given solution

Parameters

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

Definition at line 13796 of file cons_quadratic.c.

References computeViolation(), CONSHDLR_NAME, MIN, NULL, SCIP_CALL, SCIP_OKAY, SCIPABORT, SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPerrorMessage, SCIPgetActivityQuadratic(), SCIPinfinity(), and SCIPisInfinity().

Referenced by SCIPchgRhsQuadratic().

SCIP_RETCODE SCIPgetActivityQuadratic	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_SOL *	sol,
		SCIP_Real *	activity
	)

gets the activity of the quadratic constraint in the given solution

Parameters

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

Definition at line 13837 of file cons_quadratic.c.

References computeViolation(), CONSHDLR_NAME, NULL, SCIP_CALL, SCIP_OKAY, SCIPABORT, SCIPchgLinearCoefQuadratic(), SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), and SCIPerrorMessage.

Referenced by SCIPgetFeasibilityQuadratic().

SCIP_RETCODE SCIPchgLinearCoefQuadratic	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var,
		SCIP_Real	coef
	)

changes the linear coefficient value for a given quadratic variable in a quadratic constraint data; if not available, it adds it

Note: this is only allowed for original constraints and variables in problem creation stage

Parameters

scip	SCIP data structure
cons	constraint data
var	quadratic variable
coef	new coefficient

Definition at line 13871 of file cons_quadratic.c.

References addLinearCoef(), chgLinearCoefPos(), CONSHDLR_NAME, delLinearCoefPos(), FALSE, NULL, SCIP_Bool, SCIP_CALL, SCIP_INVALID, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_STAGE_PROBLEM, SCIPchgSquareCoefQuadratic(), SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPconsIsOriginal(), SCIPerrorMessage, SCIPgetStage(), SCIPintervalSetEmpty(), SCIPisZero(), SCIPvarIsOriginal(), and TRUE.

Referenced by SCIPgetActivityQuadratic().

SCIP_RETCODE SCIPchgSquareCoefQuadratic	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var,
		SCIP_Real	coef
	)

changes the square coefficient value for a given quadratic variable in a quadratic constraint data; if not available, it adds it

Note: this is only allowed for original constraints and variables in problem creation stage

Parameters

scip	SCIP data structure
cons	constraint data
var	quadratic variable
coef	new coefficient

Definition at line 13964 of file cons_quadratic.c.

References addQuadVarTerm(), CONSHDLR_NAME, FALSE, NULL, REALABS, SCIP_Bool, SCIP_CALL, SCIP_INVALID, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_STAGE_PROBLEM, SCIPchgBilinCoefQuadratic(), SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPconsIsOriginal(), SCIPerrorMessage, SCIPgetStage(), SCIPintervalSetEmpty(), SCIPisInfinity(), SCIPisZero(), SCIPvarIsOriginal(), and TRUE.

Referenced by SCIPchgBilinCoefQuadratic(), and SCIPchgLinearCoefQuadratic().

SCIP_RETCODE SCIPchgBilinCoefQuadratic	(	SCIP *	scip,
		SCIP_CONS *	cons,
		SCIP_VAR *	var1,
		SCIP_VAR *	var2,
		SCIP_Real	coef
	)

changes the bilinear coefficient value for a given quadratic variable in a quadratic constraint data; if not available, it adds it

Note: this is only allowed for original constraints and variables in problem creation stage

Parameters

scip	SCIP data structure
cons	constraint
var1	first variable
var2	second variable
coef	coefficient of bilinear term

Definition at line 14033 of file cons_quadratic.c.

References CONSHDLR_NAME, FALSE, NULL, REALABS, SCIP_Bool, SCIP_CALL, SCIP_INVALID, SCIP_INVALIDDATA, SCIP_OKAY, SCIP_STAGE_PROBLEM, SCIPaddBilinTermQuadratic(), SCIPchgSquareCoefQuadratic(), SCIPconsGetData(), SCIPconsGetHdlr(), SCIPconshdlrGetName(), SCIPconsIsOriginal(), SCIPerrorMessage, SCIPgetStage(), SCIPintervalSetEmpty(), SCIPisInfinity(), SCIPisZero(), SCIPvarIsOriginal(), and TRUE.

Referenced by SCIPchgSquareCoefQuadratic().

SCIP

Detailed Description

Macros

Typedefs

Functions

Macro Definition Documentation

Typedef Documentation

Function Documentation