Scippy

SCIP

Solving Constraint Integer Programs

cons_quadratic.c File Reference

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_RealSCIPgetCoefsLinearVarsQuadratic (SCIP *scip, SCIP_CONS *cons)
 
int SCIPgetNQuadVarTermsQuadratic (SCIP *scip, SCIP_CONS *cons)
 
SCIP_QUADVARTERMSCIPgetQuadVarTermsQuadratic (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_BILINTERMSCIPgetBilinTermsQuadratic (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_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

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
scipSCIP data structure
conshdlrdataconstraint handler data
conshdlrnamename 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
scipSCIP data structure
eventhdlrevent handler
consconstraint for which to catch bound change events
linvarposposition 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
scipSCIP data structure
eventhdlrevent handler
consconstraint for which to catch bound change events
linvarposposition 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
scipSCIP data structure
eventhdlrevent handler
consconstraint for which to catch bound change events
quadvarposposition 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
scipSCIP data structure
eventhdlrevent handler
consconstraint for which to catch bound change events
quadvarposposition 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
scipSCIP data structure
eventhdlrevent handler
consconstraint 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
scipSCIP data structure
eventhdlrevent handler
consconstraint 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
scipSCIP data structure
consconstraint where to lock a variable
varvariable to lock
coefcoefficient 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
scipSCIP data structure
consconstraint where to unlock a variable
varvariable to unlock
coefcoefficient 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
scipSCIP data structure
consconstraint where to lock a variable
varvariable 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
scipSCIP data structure
consconstraint where to unlock a variable
varvariable 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
scipSCIP data structure
consdataconstraint data
intervalinftyinfinity 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
scipSCIP data structure
consdataconstraint data
coefcoefficient of variable in constraint
oldbndprevious lower bound of variable
newbndnew 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
scipSCIP data structure
consdataconstraint data
coefcoefficient of variable in constraint
oldbndprevious lower bound of variable
newbndnew 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_RETCODE consdataEnsureLinearVarsSize ( SCIP scip,
SCIP_CONSDATA consdata,
int  num 
)
static

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

Parameters
scipSCIP data structure
consdataquadratic constraint data
numminimum 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
scipSCIP data structure
consdataquadratic constraint data
numminimum 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
scipSCIP data structure
quadvartermquadratic variable term
numminimum 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
scipSCIP data structure
consdataquadratic constraint data
numminimum 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
scipSCIP data structure
consdataa 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
scipSCIP data structure
consdataa buffer to store pointer to new constraint data
lhsleft hand side of constraint
rhsright hand side of constraint
nlinvarsnumber of linear variables
linvarsarray of linear variables
lincoefsarray of coefficients of linear variables
nquadvarsnumber of quadratic variables
quadvartermsarray of quadratic variable terms
nbilintermsnumber of bilinear terms
bilintermsarray of bilinear terms
capturevarswhether 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
scipSCIP data structure
consdatapointer 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
consdataquadratic 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
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
scipSCIP data structure
consdataquadratic constraint data
varvariable to search for
posbuffer 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
scipSCIP data structure
consdataquadratic 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
consdataconstraint data
oldposposition of variable that shall be moved
newposnew 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
consdataconstraint data
oldposposition of variable that shall be moved
newposnew 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 delLinearCoefPos ( SCIP scip,
SCIP_CONS cons,
int  pos 
)
static

deletes linear coefficient at given position from quadratic constraint data

Parameters
scipSCIP data structure
consquadratic constraint
posposition 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
scipSCIP data structure
consquadratic constraint
posposition of linear coefficient to change
newcoefnew 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 delQuadVarTermPos ( SCIP scip,
SCIP_CONS cons,
int  pos 
)
static

deletes quadratic variable term at given position from quadratic constraint data

Parameters
scipSCIP data structure
consquadratic constraint
posposition 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
scipSCIP data structure
consquadratic constraint
posposition of term to replace
varnew variable
coeflinear coefficient of new variable
offsetoffset 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
scipSCIP data structure
consquadratic constraint
var1posposition of first variable in quadratic variables array
var2posposition of second variable in quadratic variables array
coefcoefficient 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
scipSCIP data structure
consquadratic constraint
ntermsnumber of terms to delete
termpossindices 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
scipSCIP data structure
consquadratic 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
scipSCIP data structure
consquadratic 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
static SCIP_RETCODE createNlRow ( SCIP scip,
SCIP_CONS cons 
)
static
static SCIP_RETCODE presolveSolve ( SCIP scip,
SCIP_CONS cons,
SCIP_RESULT result,
SCIP_Bool redundant,
int *  naggrvars 
)
static

solve constraint as presolving

Parameters
scipSCIP data structure
consconstraint
resultto store result of solve: cutoff, success, or do-not-find
redundantto store whether constraint is redundant now (should be deleted)
naggrvarscounter 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
scipSCIP data structure
conshdlrconstraint handler
consconstraint
naddconssbuffer 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
scipSCIP data structure
xvariable which implications to check
xvalvalue of x to check for (TRUE for 1, FALSE for 0)
yvariable to check if bounds can be reduced
resultantbuffer 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
scipSCIP data structure
conshdlrconstraint handler
consconstraint
naddconssbuffer 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
scipSCIP data structure
conshdlrconstraint handler data structure
conssource constraint to try to convert
upgradedbuffer to store whether constraint was upgraded
nupgdconssbuffer to increase if constraint was upgraded
naddconssbuffer to increase with number of additional constraints created during upgrade
presoltimingcurrent 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
scipSCIP data structure
consdataconstraint data
quadvaridxindex of quadratic variable to mark
var2componentvariables to components mapping
componentnrthe 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
scipSCIP data structure
conshdlrconstraint handler data structure
conssource constraint to try to convert
naddconsspointer 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
scipSCIP data structure
consquadratic constraint
determinedpointer to store whether the curvature could be determined
checkmultivariatewhether 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_Real getGradientMaxElement ( SCIP scip,
SCIP_CONS cons,
SCIP_SOL sol 
)
static

gets maximal absolute value in gradient of quadratic function

Parameters
scipSCIP data structure
consconstraint
solsolution 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
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
scipSCIP data structure
conshdlrconstraint handler
conssconstraints
nconssnumber of constraints
solsolution or NULL if LP solution should be used
maxviolconbuffer 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
scipSCIP data structure
consconstraint
refreference solution where to generate the cut
multleftmultiplicator on lhs
coefleftcoefficient for factor on lhs
multrightmultiplicator on both sides
coefrightcoefficient for factor that goes to rhs
rightminactivityminimal activity of <coefright, x>
rightmaxactivitymaximal activity of <coefright, x>
rhsdenominator on rhs
cutcoefarray to store cut coefficients for quadratic variables
cutrhsbuffer to store cut rhs
islocalbuffer to set to TRUE if local information was used
successbuffer to indicate whether a cut was successfully computed
namebuffer 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
scipSCIP data structure
consconstraint
violsidefor which side a cut should be generated
refreference solution where to generate the cut
cutcoefarray to store cut coefficients for quadratic variables
cutlhsbuffer to store cut lhs
cutrhsbuffer to store cut rhs
islocalbuffer to set to TRUE if local information was used
successbuffer to indicate whether a cut was successfully computed
namebuffer 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
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
scipSCIP data structure
xllower bound on x
xuupper bound on x
x0reference point for x
yllower bound on y
yuupper bound on y
y0_reference point for y
wllower bound on w
wuupper bound on w
w0reference point for w
cxbuffer where to store cut coefficient for x
cybuffer where to store cut coefficient for y
cwbuffer where to store cut coefficient for w
c0buffer where to store cut left-hand-side
successbuffer 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
scipSCIP data structure
consconstraint
violsidefor which side a cut should be generated
refreference solution where to generate the cut
solsolution that shall be cutoff, NULL for LP solution
cutcoeflinbuffer to store pointer to array with coefficients for linear variables
cutcoefquadarray to store cut coefficients for quadratic variables
cutlhsbuffer to store cut lhs
cutrhsbuffer to store cut rhs
islocalbuffer to set to TRUE if local information was used
successbuffer to indicate whether a cut was successfully computed
namebuffer 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
scipSCIP data structure
consconstraint
violsideside for which to generate cut
refreference solution where to generate the cut
coefarray to store cut coefficients w.r.t. quadratic variables
lhsbuffer to store left-hand-side of cut
rhsbuffer to store right-hand-side of cut
islocalbuffer to set to TRUE if local bounds were used
successbuffer to indicate whether a cut was successfully computed
namebuffer 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
scipSCIP data structure
consconstraint
violsideside for which to generate cut
refreference solution where to generate the cut
coefarray to store cut coefficients w.r.t. quadratic variables
lhsbuffer to store left-hand-side of cut
rhsbuffer to store right-hand-side of cut
islocalbuffer to set to TRUE if local bounds were used
successbuffer to indicate whether a cut was successfully computed
namebuffer 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
scipSCIP data structure
conshdlrconstraint handler
consconstraint
refreference solution where to generate the cut
solpoint that we aim to separate, or NULL for LP solution
violsidefor which side a cut should be generated
rowstorage for cut
efficacybuffer to store efficacy of row in reference solution, or NULL if not of interest
checkcurvmultivarare we allowed to check the curvature of a multivariate quadratic function, if not done yet
minefficacyminimal 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
scipSCIP data structure
consconstraint
methodmethod for computing interior point ('a' any point, 'm'ost interior)
successbuffer 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:

  1. compute interior point
  2. compute gauge function
Parameters
scipSCIP data structure
conshdlrconstraint handler
consconstraint

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
scipSCIP data structure
conshdlrconstraint handler
consconstraint
refsolreference point where to generate cut, or NULL if sol should be used
gaugevalbuffer to store the value of the gauge function
successbuffer 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
scipSCIP data structure
conshdlrconstraint handler
consconstraint
refsolreference point where to compute gauge, or NULL if LP solution should be used
refpointer to store reference point
successbuffer 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
scipSCIP data structure
conshdlrconstraint handler
consconstraint
solsolution where to generate cut, or NULL if LP solution should be used
refsolreference point where to generate cut, or NULL if sol should be used
violsidefor which side a cut should be generated
rowstorage for cut
efficacybuffer to store efficacy of row in reference solution, or NULL if not of interest
checkcurvmultivarare we allowed to check the curvature of a multivariate quadratic function, if not done yet
minefficacyminimal 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
scipSCIP data structure
conshdlrconstraint handler
consconstraint
violsidefor which side a cut should be generated
rowstorage for cut
rowrayprodbuffer to store product of ray with row coefficients, or NULL if not of interest
checkcurvmultivarare 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
scipSCIP data structure
conshdlrquadratic constraints handler
conssconstraints
nconssnumber of constraints
nusefulconssnumber of constraints that seem to be useful
solsolution to separate, or NULL if LP solution should be used
minefficacyminimal efficacy of a cut if it should be added to the LP
inenforcementwhether we are in constraint enforcement
resultresult of separation
bestefficacybuffer 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
scipSCIP data structure
conshdlrquadratic constraints handler
conssconstraints
nconssnumber of constraints
refreference point where to linearize, or NULL for LP solution
separatedlpsolbuffer to store whether a cut that separates the current LP solution was found and added to LP, or NULL if adding to cutpool only
minefficacyminimal 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
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
scipSCIP data structure
conshdlrconstraint handler
conssconstraints to check
nconssnumber of constraints to check
nnotifycounter 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
scipSCIP data structure
conshdlrconstraint handler
conssconstraints to check
nconssnumber of constraints to check
nnotifycounter 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
scipSCIP data structure
conshdlrconstraint handler
conssconstraints to check
nconssnumber of constraints to check
nnotifycounter 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
scipSCIP data structure
conshdlrconstraint handler
conssconstraints to check
nconssnumber of constraints to check
nnotifycounter 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
scipSCIP data structure
conssconstraints
nconssnumber of constraints
brvarbuffer 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
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
scipSCIP data structure
consconstraint where we currently propagate
intervalinftyinfinity value used in interval operations
varvariable which domain we might reduce
bndnew lower bound for variable
resultresult to update if there was a tightening or cutoff
nchgbdscounter 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
scipSCIP data structure
consconstraint where we currently propagate
intervalinftyinfinity value used in interval operations
varvariable which domain we might reduce
bndnew upper bound for variable
resultresult to update if there was a tightening or cutoff
nchgbdscounter 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
scipSCIP data structure
consconstraint where we currently propagate
intervalinftyinfinity value used in interval operations
varvariable which bounds with might tighten
acoefficient in square term
bcoefficient in linear term
rhsright hand side of quadratic equation
resultresult of propagation
nchgbdsbuffer 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
scipSCIP data structure
consthe constraint, where the bilinear term belongs to
intervalinftyinfinity value used in interval operations
xfirst variable
xsqrcoefsquare coefficient of x
xlincoeflinear coefficient of x
ysecond variable
ysqrcoefsquare coefficient of y
ylincoeflinear coefficient of y
bilincoefbilinear coefficient of x*y
rhsright hand side of quadratic equation
resultpointer to store result of domain propagation
nchgbdscounter 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
scipSCIP data structure
consdataconstraint data
intervalinftyinfinity value used in interval operations
minquadactivityminimal activity of quadratic variable terms where only terms with finite minimal activity contribute
maxquadactivitymaximal activity of quadratic variable terms where only terms with finite maximal activity contribute
minactivityinfnumber of quadratic variables that contribute -infinity to minimal activity
maxactivityinfnumber of quadratic variables that contribute +infinity to maximal activity
quadactcontrcontribution 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
scipSCIP data structure
conshdlrconstraint handler
consconstraint to process
resultpointer to store the result of the propagation call
nchgbdsbuffer where to add the the number of changed bounds
redundantbuffer 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
scipSCIP data structure
conshdlrconstraint handler
conssconstraints to process
nconssnumber of constraints
resultpointer to store the result of the propagation calls
nchgbdsbuffer 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
scipSCIP data structure
consdataconstraint 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
scipSCIP data structure
conshdlrconstraint handler
conssconstraints to process
nconssnumber of constraints
solsolution to process
successbuffer 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.

References NULL, SCIP_CALL, SCIP_DECL_CONSHDLRCOPY(), SCIP_ERROR, SCIP_EXPR_ABS, SCIP_EXPR_CONST, SCIP_EXPR_COS, SCIP_EXPR_DIV, SCIP_EXPR_EXP, SCIP_EXPR_INTPOWER, SCIP_EXPR_LAST, SCIP_EXPR_LINEAR, SCIP_EXPR_LOG, SCIP_EXPR_MAX, SCIP_EXPR_MIN, SCIP_EXPR_MINUS, SCIP_EXPR_MUL, SCIP_EXPR_PARAM, SCIP_EXPR_PLUS, SCIP_EXPR_POLYNOMIAL, SCIP_EXPR_PRODUCT, SCIP_EXPR_QUADRATIC, SCIP_EXPR_REALPOWER, SCIP_EXPR_SIGN, SCIP_EXPR_SIGNPOWER, SCIP_EXPR_SIN, SCIP_EXPR_SQRT, SCIP_EXPR_SQUARE, SCIP_EXPR_SUM, SCIP_EXPR_TAN, SCIP_EXPR_USER, SCIP_EXPR_VARIDX, SCIP_OKAY, SCIP_Real, SCIPaddBilinTermQuadratic(), SCIPaddConstantQuadratic(), SCIPaddQuadVarLinearCoefQuadratic(), SCIPaddQuadVarQuadratic(), SCIPaddSquareCoefQuadratic(), SCIPconsGetHdlr(), SCIPconsGetName(), SCIPconsIsChecked(), SCIPconsIsDynamic(), SCIPconsIsEnforced(), SCIPconsIsInitial(), SCIPconsIsLocal(), SCIPconsIsModifiable(), SCIPconsIsPropagated(), SCIPconsIsRemovable(), SCIPconsIsSeparated(), SCIPconsIsStickingAtNode(), SCIPcreateConsQuadratic(), SCIPerrorMessage, SCIPexprgraphAreAllNodeChildrenVars(), SCIPexprgraphGetNodeChildren(), SCIPexprgraphGetNodeNChildren(), SCIPexprgraphGetNodeOperator(), SCIPexprgraphGetNodeQuadraticConstant(), SCIPexprgraphGetNodeQuadraticLinearCoefs(), SCIPexprgraphGetNodeQuadraticNQuadElements(), SCIPexprgraphGetNodeQuadraticQuadElements(), SCIPexprgraphGetNodeVar(), SCIPgetExprgraphNodeNonlinear(), SCIPgetExprgraphNonlinear(), SCIPgetLhsNonlinear(), SCIPgetLinearCoefsNonlinear(), SCIPgetLinearVarsNonlinear(), SCIPgetNLinearVarsNonlinear(), SCIPgetRhsNonlinear(), and SCIPwarningMessage().

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_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_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_CONSENFOPS ( consEnfopsQuadratic  )
static
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_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_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
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 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
scipSCIP data structure
prioritypriority of upgrading method
activeshould the upgrading method be active by default?
conshdlrnamename 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
scipSCIP data structure
conspointer to hold the created constraint
namename of constraint
nlinvarsnumber of linear terms (n)
linvarsarray with variables in linear part (x_i)
lincoefsarray with coefficients of variables in linear part (b_i)
nquadtermsnumber of quadratic terms (m)
quadvars1array with first variables in quadratic terms (y_j)
quadvars2array with second variables in quadratic terms (z_j)
quadcoefsarray with coefficients of quadratic terms (a_j)
lhsleft hand side of quadratic equation (ell)
rhsright hand side of quadratic equation (u)
initialshould the LP relaxation of constraint be in the initial LP? Usually set to TRUE. Set to FALSE for 'lazy constraints'.
separateshould the constraint be separated during LP processing? Usually set to TRUE.
enforceshould the constraint be enforced during node processing? TRUE for model constraints, FALSE for additional, redundant constraints.
checkshould the constraint be checked for feasibility? TRUE for model constraints, FALSE for additional, redundant constraints.
propagateshould the constraint be propagated during node processing? Usually set to TRUE.
localis constraint only valid locally? Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints.
modifiableis constraint modifiable (subject to column generation)? Usually set to FALSE. In column generation applications, set to TRUE if pricing adds coefficients to this constraint.
dynamicis constraint subject to aging? Usually set to FALSE. Set to TRUE for own cuts which are separated as constraints.
removableshould 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
scipSCIP data structure
conspointer to hold the created constraint
namename of constraint
nlinvarsnumber of linear terms (n)
linvarsarray with variables in linear part (x_i)
lincoefsarray with coefficients of variables in linear part (b_i)
nquadtermsnumber of quadratic terms (m)
quadvars1array with first variables in quadratic terms (y_j)
quadvars2array with second variables in quadratic terms (z_j)
quadcoefsarray with coefficients of quadratic terms (a_j)
lhsleft hand side of quadratic equation (ell)
rhsright 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
scipSCIP data structure
conspointer to hold the created constraint
namename of constraint
nlinvarsnumber of linear terms (n)
linvarsarray with variables in linear part (x_i)
lincoefsarray with coefficients of variables in linear part (b_i)
nquadvartermsnumber of quadratic terms (m)
quadvartermsquadratic variable terms
nbilintermsnumber of bilinear terms (p)
bilintermsbilinear terms
lhsconstraint left hand side (ell)
rhsconstraint right hand side (u)
initialshould the LP relaxation of constraint be in the initial LP?
separateshould the constraint be separated during LP processing?
enforceshould the constraint be enforced during node processing?
checkshould the constraint be checked for feasibility?
propagateshould the constraint be propagated during node processing?
localis constraint only valid locally?
modifiableis constraint modifiable (subject to column generation)?
dynamicis constraint dynamic?
removableshould 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
scipSCIP data structure
conspointer to hold the created constraint
namename of constraint
nlinvarsnumber of linear terms (n)
linvarsarray with variables in linear part (x_i)
lincoefsarray with coefficients of variables in linear part (b_i)
nquadvartermsnumber of quadratic terms (m)
quadvartermsquadratic variable terms
nbilintermsnumber of bilinear terms (p)
bilintermsbilinear terms
lhsconstraint left hand side (ell)
rhsconstraint 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
scipSCIP data structure
consconstraint
constantconstant 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
scipSCIP data structure
consconstraint
varvariable
coefcoefficient 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
scipSCIP data structure
consconstraint
varvariable
lincoeflinear coefficient of variable
sqrcoefsquare 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
scipSCIP data structure
consconstraint
varvariable
coefvalue 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
scipSCIP data structure
consconstraint
varvariable
coefvalue 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
scipSCIP data structure
consconstraint
var1first variable
var2second variable
coefcoefficient 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
scipSCIP data structure
consconstraint
nlrowpointer 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
scipSCIP data structure
consconstraint

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
scipSCIP data structure
consconstraint

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
scipSCIP data structure
consconstraint

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
scipSCIP data structure
consconstraint

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
scipSCIP data structure
consconstraint

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
scipSCIP data structure
consconstraint

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
scipSCIP data structure
consconstraint
varvariable to search for
posbuffer 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
scipSCIP data structure
consconstraint

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
scipSCIP data structure
consconstraint

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
scipSCIP data structure
consconstraint

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
scipSCIP data structure
consconstraint

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
scipSCIP data structure
consconstraint

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
scipSCIP data structure
consconstraint

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
scipSCIP data structure
consconstraint

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
scipSCIP data structure
consconstraint
solsolution which violation to calculate, or NULL for LP solution
violationpointer 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
scipSCIP data structure
consconstraint

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
scipSCIP data structure
consconstraint
nlpiinterface to NLP solver
nlpiprobNLPI problem where to add constraint
scipvar2nlpivarmapping from SCIP variables to variable indices in NLPI
nameswhether 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
scipSCIP data structure
consconstraint data
lhsnew 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
scipSCIP data structure
consconstraint data
rhsnew 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
scipSCIP data structure
consconstraint data
solsolution, or NULL to use current node's solution
feasibilitypointer 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
scipSCIP data structure
consconstraint data
solsolution, or NULL to use current node's solution
activitypointer 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
scipSCIP data structure
consconstraint data
varquadratic variable
coefnew 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
scipSCIP data structure
consconstraint data
varquadratic variable
coefnew 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
scipSCIP data structure
consconstraint
var1first variable
var2second variable
coefcoefficient 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().