Scippy

SCIP

Solving Constraint Integer Programs

cons_nonlinear.h
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the program and library */
4 /* SCIP --- Solving Constraint Integer Programs */
5 /* */
6 /* Copyright (C) 2002-2018 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SCIP is distributed under the terms of the ZIB Academic License. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SCIP; see the file COPYING. If not email to scip@zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file cons_nonlinear.h
17  * @ingroup CONSHDLRS
18  * @brief constraint handler for nonlinear constraints \f$\textrm{lhs} \leq \sum_{i=1}^n a_ix_i + \sum_{j=1}^m c_jf_j(x) \leq \textrm{rhs}\f$
19  * @author Stefan Vigerske
20  *
21  */
22 
23 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
24 
25 #ifndef __SCIP_CONS_NONLINEAR_H__
26 #define __SCIP_CONS_NONLINEAR_H__
27 
28 #include "scip/scip.h"
29 
30 #ifdef __cplusplus
31 extern "C" {
32 #endif
33 
34 /** upgrading method for nonlinear constraints into more specific constraints
35  *
36  * the method might upgrade a nonlinear constraint into a set of upgrade constraints
37  * the caller provided an array upgdconss to store upgrade constraints
38  * the length of upgdconss is given by upgdconsssize
39  * if an upgrade is not possible, set *nupgdconss to zero
40  * if more than upgdconsssize many constraints shall replace cons, the function
41  * should return the required number as negated value in *nupgdconss
42  * i.e., if cons should be replaced by 3 constraints, the function should set
43  * *nupgdconss to -3 and return with SCIP_OKAY
44  *
45  * input:
46  * - scip : SCIP main data structure
47  * - cons : the nonlinear constraint to upgrade
48  * - nupgdconss : pointer to store number of constraints that replace this constraint
49  * - upgdconss : array to store constraints that replace this constraint
50  * - upgdconsssize : length of the provided upgdconss array
51  */
52 #define SCIP_DECL_NONLINCONSUPGD(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONS* cons, \
53  int* nupgdconss, SCIP_CONS** upgdconss, int upgdconsssize)
54 
55 /** reformulation method for expression graph nodes
56  *
57  * The method might reformulate a node in an expression graph by adding
58  * auxiliary constraints and/or variables.
59  * The caller provided an expression graph node which is to be reformulated.
60  * If the method takes action, it has to return the node that should replace
61  * the given node in *reformnode. The caller will then ensure that all parents of
62  * node will use *reformnode, so node may be freed.
63  * If the method does not do any reformulation, it shall return NULL in *reformnode.
64  * The counter naddcons can be used to setup the names of added variables/constraints.
65  * The method should increase this counter by the number of added constraints.
66  * The method has to ensure that the reformulated node, if still valid,
67  * has valid bound and curvature information.
68  *
69  * input:
70  * - scip : SCIP main data structure
71  * - exprgraph : the expression graph which node to reformulate
72  * - node : the expression graph node to reformulate
73  * - naddcons : counter on number of added constraints so far
74  *
75  * output:
76  * - naddcons : to be increased by number of additionally added constraints
77  * - reformnode : reformulated node to replace node with, or NULL if no reformulation
78  */
79 #define SCIP_DECL_EXPRGRAPHNODEREFORM(x) SCIP_RETCODE x (SCIP* scip, \
80  SCIP_EXPRGRAPH* exprgraph, SCIP_EXPRGRAPHNODE* node, \
81  int* naddcons, SCIP_EXPRGRAPHNODE** reformnode)
82 
83 /** creates the handler for nonlinear constraints and includes it in SCIP
84  *
85  * @ingroup ConshdlrIncludes
86  * */
87 extern
89  SCIP* scip /**< SCIP data structure */
90  );
91 
92 /**@addtogroup CONSHDLRS
93  *
94  * @{
95  *
96  * @name Nonlinear Constraints
97  *
98  * @{
99  *
100  * This constraint handler handles constraints of the form
101  * \f[
102  * \textrm{lhs} \leq \sum_{i=1}^n a_ix_i + \sum_{j=1}^m c_jf_j(x) \leq \textrm{rhs},
103  * \f]
104  * where \f$a_i\f$ and \f$c_j\f$ are coefficients and
105  * \f$f_j(x)\f$ are nonlinear functions (given as expression tree).
106  *
107  * Constraints are enforced by separation, domain propagation, and spatial branching.
108  *
109  * For convex or concave \f$f_j(x)\f$, cuts that separate on the convex hull of the function graph are implemented.
110  * For \f$f_j(x)\f$ that are not known to be convex or concave, a simple variant of linear estimation based on interval gradients is implemented.
111  *
112  * Branching is performed for variables in nonconvex terms, if the relaxation solution cannot be separated.
113  *
114  * This header offers the upgrade functionality to upgrade a general nonlinear constraint into a more specific constraint
115  * via SCIP_DECL_NONLINCONSUPGD().
116  *
117  * Furthermore, the definition of callbacks used to reformulate an expression graph is offered by
118  * SCIP_DECL_EXPRGRAPHNODEREFORM().
119  *
120  * Further, the function representation is stored in an expression graph, which allows to propagate variable domains
121  * and constraint sides and offers a simple convexity check.
122  * During presolve, the expression graph is reformulated, whereby new variables and constraints are created
123  * such that for the remaining nonlinear constraints the functions \f$f_j(x)\f$ are known to be convex or concave.
124  * See also
125  *
126  * @par
127  * Stefan Vigerske@n
128  * Decomposition of Multistage Stochastic Programs and a Constraint Integer Programming Approach to Mixed-Integer Nonlinear Programming@n
129  * PhD Thesis, Humboldt-University Berlin, 2012, submitted.
130  */
131 
132 /** includes a nonlinear constraint upgrade method into the nonlinear constraint handler */
133 extern
135  SCIP* scip, /**< SCIP data structure */
136  SCIP_DECL_NONLINCONSUPGD((*nonlinconsupgd)),/**< method to call for upgrading nonlinear constraint, or NULL */
137  SCIP_DECL_EXPRGRAPHNODEREFORM((*nodereform)),/**< method to call for reformulating expression graph node, or NULL */
138  int priority, /**< priority of upgrading method */
139  SCIP_Bool active, /**< should the upgrading method by active by default? */
140  const char* conshdlrname /**< name of the constraint handler */
141  );
142 
143 /** creates and captures a nonlinear constraint
144  * this variant takes expression trees as input
145  *
146  * @note the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()
147  */
148 extern
150  SCIP* scip, /**< SCIP data structure */
151  SCIP_CONS** cons, /**< pointer to hold the created constraint */
152  const char* name, /**< name of constraint */
153  int nlinvars, /**< number of linear variables in the constraint */
154  SCIP_VAR** linvars, /**< array with linear variables of constraint entries */
155  SCIP_Real* lincoefs, /**< array with coefficients of constraint linear entries */
156  int nexprtrees, /**< number of expression trees for nonlinear part of constraint */
157  SCIP_EXPRTREE** exprtrees, /**< expression trees for nonlinear part of constraint */
158  SCIP_Real* nonlincoefs, /**< coefficients for expression trees for nonlinear part, or NULL if all 1.0 */
159  SCIP_Real lhs, /**< left hand side of constraint */
160  SCIP_Real rhs, /**< right hand side of constraint */
161  SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP?
162  * Usually set to TRUE. Set to FALSE for 'lazy constraints'. */
163  SCIP_Bool separate, /**< should the constraint be separated during LP processing?
164  * Usually set to TRUE. */
165  SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
166  * TRUE for model constraints, FALSE for additional, redundant constraints. */
167  SCIP_Bool check, /**< should the constraint be checked for feasibility?
168  * TRUE for model constraints, FALSE for additional, redundant constraints. */
169  SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
170  * Usually set to TRUE. */
171  SCIP_Bool local, /**< is constraint only valid locally?
172  * Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
173  SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)?
174  * Usually set to FALSE. In column generation applications, set to TRUE if pricing
175  * adds coefficients to this constraint. */
176  SCIP_Bool dynamic, /**< is constraint subject to aging?
177  * Usually set to FALSE. Set to TRUE for own cuts which
178  * are seperated as constraints. */
179  SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
180  * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
181  SCIP_Bool stickingatnode /**< should the constraint always be kept at the node where it was added, even
182  * if it may be moved to a more global node?
183  * Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
184  );
185 
186 /** creates and captures a nonlinear constraint
187  * in its most basic version, i. e., all constraint flags are set to their basic value as explained for the
188  * method SCIPcreateConsNonlinear(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h
189  *
190  * this variant takes expression trees as input
191  *
192  * @see SCIPcreateConsNonlinear() for information about the basic constraint flag configuration
193  *
194  * @note the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()
195  */
196 extern
198  SCIP* scip, /**< SCIP data structure */
199  SCIP_CONS** cons, /**< pointer to hold the created constraint */
200  const char* name, /**< name of constraint */
201  int nlinvars, /**< number of linear variables in the constraint */
202  SCIP_VAR** linvars, /**< array with linear variables of constraint entries */
203  SCIP_Real* lincoefs, /**< array with coefficients of constraint linear entries */
204  int nexprtrees, /**< number of expression trees for nonlinear part of constraint */
205  SCIP_EXPRTREE** exprtrees, /**< expression trees for nonlinear part of constraint */
206  SCIP_Real* nonlincoefs, /**< coefficients for expression trees for nonlinear part, or NULL if all 1.0 */
207  SCIP_Real lhs, /**< left hand side of constraint */
208  SCIP_Real rhs /**< right hand side of constraint */
209  );
210 
211 /** creates and captures a nonlinear constraint
212  * this variant takes a node of the expression graph as input and can only be used during presolving
213  * it is assumed that the nonlinear constraint will be added to the transformed problem short after creation
214  * the given exprgraphnode is captured in this method
215  *
216  * @note the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()
217  */
218 extern
220  SCIP* scip, /**< SCIP data structure */
221  SCIP_CONS** cons, /**< pointer to hold the created constraint */
222  const char* name, /**< name of constraint */
223  int nlinvars, /**< number of linear variables in the constraint */
224  SCIP_VAR** linvars, /**< array with linear variables of constraint entries */
225  SCIP_Real* lincoefs, /**< array with coefficients of constraint linear entries */
226  SCIP_EXPRGRAPHNODE* exprgraphnode, /**< expression graph node associated to nonlinear expression */
227  SCIP_Real lhs, /**< left hand side of constraint */
228  SCIP_Real rhs, /**< right hand side of constraint */
229  SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP?
230  * Usually set to TRUE. Set to FALSE for 'lazy constraints'. */
231  SCIP_Bool separate, /**< should the constraint be separated during LP processing?
232  * Usually set to TRUE. */
233  SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
234  * TRUE for model constraints, FALSE for additional, redundant constraints. */
235  SCIP_Bool check, /**< should the constraint be checked for feasibility?
236  * TRUE for model constraints, FALSE for additional, redundant constraints. */
237  SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
238  * Usually set to TRUE. */
239  SCIP_Bool local, /**< is constraint only valid locally?
240  * Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
241  SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)?
242  * Usually set to FALSE. In column generation applications, set to TRUE if pricing
243  * adds coefficients to this constraint. */
244  SCIP_Bool dynamic, /**< is constraint subject to aging?
245  * Usually set to FALSE. Set to TRUE for own cuts which
246  * are seperated as constraints. */
247  SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
248  * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
249  SCIP_Bool stickingatnode /**< should the constraint always be kept at the node where it was added, even
250  * if it may be moved to a more global node?
251  * Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
252  );
253 
254 /** creates and captures a nonlinear constraint
255  * in its most basic version, i. e., all constraint flags are set to their basic value as explained for the
256  * method SCIPcreateConsNonlinear2(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h
257  *
258  * this variant takes a node of the expression graph as input and can only be used during presolving
259  * it is assumed that the nonlinear constraint will be added to the transformed problem short after creation
260  * the given exprgraphnode is captured in this method
261  *
262  * @see SCIPcreateConsNonlinear2() for information about the basic constraint flag configuration
263  *
264  * @note the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()
265  */
266 extern
268  SCIP* scip, /**< SCIP data structure */
269  SCIP_CONS** cons, /**< pointer to hold the created constraint */
270  const char* name, /**< name of constraint */
271  int nlinvars, /**< number of linear variables in the constraint */
272  SCIP_VAR** linvars, /**< array with linear variables of constraint entries */
273  SCIP_Real* lincoefs, /**< array with coefficients of constraint linear entries */
274  SCIP_EXPRGRAPHNODE* exprgraphnode, /**< expression graph node associated to nonlinear expression */
275  SCIP_Real lhs, /**< left hand side of constraint */
276  SCIP_Real rhs /**< right hand side of constraint */
277  );
278 
279 /** adds a linear variable with coefficient to a nonlinear constraint */
280 extern
282  SCIP* scip, /**< SCIP data structure */
283  SCIP_CONS* cons, /**< constraint */
284  SCIP_VAR* var, /**< variable */
285  SCIP_Real coef /**< coefficient of variable */
286  );
287 
288 /** sets the expression trees in a nonlinear constraint
289  * constraint must not be active yet
290  */
291 extern
293  SCIP* scip, /**< SCIP data structure */
294  SCIP_CONS* cons, /**< constraint */
295  int nexprtrees, /**< number of expression trees */
296  SCIP_EXPRTREE** exprtrees, /**< new expression trees, or NULL if nexprtrees is 0 */
297  SCIP_Real* coefs /**< coefficients of expression trees, or NULL if all 1.0 */
298  );
299 
300 /** adds expression trees to a nonlinear constraint
301  * constraint must not be active yet
302  */
303 extern
305  SCIP* scip, /**< SCIP data structure */
306  SCIP_CONS* cons, /**< constraint */
307  int nexprtrees, /**< number of expression trees */
308  SCIP_EXPRTREE** exprtrees, /**< new expression trees, or NULL if nexprtrees is 0 */
309  SCIP_Real* coefs /**< coefficients of expression trees, or NULL if all 1.0 */
310  );
311 
312 /** gets the nonlinear constraint as a nonlinear row representation */
313 extern
315  SCIP* scip, /**< SCIP data structure */
316  SCIP_CONS* cons, /**< constraint */
317  SCIP_NLROW** nlrow /**< pointer to store nonlinear row */
318  );
319 
320 /** gets the number of variables in the linear term of a nonlinear constraint */
321 extern
323  SCIP* scip, /**< SCIP data structure */
324  SCIP_CONS* cons /**< constraint */
325  );
326 
327 /** gets the variables in the linear part of a nonlinear constraint */
328 extern
330  SCIP* scip, /**< SCIP data structure */
331  SCIP_CONS* cons /**< constraint */
332  );
333 
334 /** gets the coefficients in the linear part of a nonlinear constraint */
335 extern
337  SCIP* scip, /**< SCIP data structure */
338  SCIP_CONS* cons /**< constraint */
339  );
340 
341 /** gets the number of expression trees of a nonlinear constraint */
342 extern
344  SCIP* scip, /**< SCIP data structure */
345  SCIP_CONS* cons /**< constraint */
346  );
347 
348 /** gets the expression trees of a nonlinear constraint */
349 extern
351  SCIP* scip, /**< SCIP data structure */
352  SCIP_CONS* cons /**< constraint */
353  );
354 
355 /** gets the coefficients of the expression trees of a nonlinear constraint */
356 extern
358  SCIP* scip, /**< SCIP data structure */
359  SCIP_CONS* cons /**< constraint */
360  );
361 
362 /** gets the expression graph node of a nonlinear constraint */
363 extern
365  SCIP* scip, /**< SCIP data structure */
366  SCIP_CONS* cons /**< constraint */
367  );
368 
369 /** gets the left hand side of a nonlinear constraint */
370 extern
372  SCIP* scip, /**< SCIP data structure */
373  SCIP_CONS* cons /**< constraint */
374  );
375 
376 /** gets the right hand side of a nonlinear constraint */
377 extern
379  SCIP* scip, /**< SCIP data structure */
380  SCIP_CONS* cons /**< constraint */
381  );
382 
383 /** check the function of a nonlinear constraint for convexity/concavity, if not done yet */
384 extern
386  SCIP* scip, /**< SCIP data structure */
387  SCIP_CONS* cons /**< constraint */
388  );
389 
390 /** gets the curvature of the nonlinear function of a nonlinear constraint
391  *
392  * The curvature is computed by summing up the curvature for each nonlinear summand.
393  * To get the curvature for single summands, use SCIPgetExprtreeCurvaturesNonlinear().
394  */
395 extern
397  SCIP* scip, /**< SCIP data structure */
398  SCIP_CONS* cons, /**< constraint */
399  SCIP_Bool checkcurv, /**< whether to check constraint curvature, if not checked before */
400  SCIP_EXPRCURV* curvature /**< pointer to store curvature of constraint */
401  );
402 
403 /** gets the curvature of the expression trees (multiplied by their coefficient) of a nonlinear constraint */
404 extern
406  SCIP* scip, /**< SCIP data structure */
407  SCIP_CONS* cons, /**< constraint */
408  SCIP_Bool checkcurv, /**< whether to check constraint curvature, if not checked before */
409  SCIP_EXPRCURV** curvatures /**< buffer to store curvatures of exprtrees */
410  );
411 
412 /** computes the violation of a nonlinear constraint by a solution */
413 extern
415  SCIP* scip, /**< SCIP data structure */
416  SCIP_CONS* cons, /**< constraint */
417  SCIP_SOL* sol, /**< solution which violation to calculate, or NULL for LP solution */
418  SCIP_Real* violation /**< pointer to store violation of constraint */
419  );
420 
421 /** get index of a linear variable of a nonlinear constraint that may be decreased without making any other constraint infeasible, or -1 if none */
422 extern
424  SCIP* scip, /**< SCIP data structure */
425  SCIP_CONS* cons /**< constraint */
426  );
427 
428 /** get index of a linear variable of a nonlinear constraint that may be increased without making any other constraint infeasible, or -1 if none */
429 extern
431  SCIP* scip, /**< SCIP data structure */
432  SCIP_CONS* cons /**< constraint */
433  );
434 
435 /** gets expression graph of nonlinear constraint handler */
436 extern
438  SCIP* scip, /**< SCIP data structure */
439  SCIP_CONSHDLR* conshdlr /**< nonlinear constraint handler */
440  );
441 
442 /** given three points, constructs coefficient of equation for hyperplane generated by these three points
443  * Three points a, b, and c are given.
444  * Computes coefficients alpha, beta, gamma, and delta, such that a, b, and c, satisfy
445  * alpha * x1 + beta * x2 + gamma * x3 = delta and gamma >= 0.0.
446  */
447 extern
449  SCIP* scip, /**< SCIP data structure */
450  SCIP_Real a1, /**< first coordinate of a */
451  SCIP_Real a2, /**< second coordinate of a */
452  SCIP_Real a3, /**< third coordinate of a */
453  SCIP_Real b1, /**< first coordinate of b */
454  SCIP_Real b2, /**< second coordinate of b */
455  SCIP_Real b3, /**< third coordinate of b */
456  SCIP_Real c1, /**< first coordinate of c */
457  SCIP_Real c2, /**< second coordinate of c */
458  SCIP_Real c3, /**< third coordinate of c */
459  SCIP_Real* alpha, /**< coefficient of first coordinate */
460  SCIP_Real* beta, /**< coefficient of second coordinate */
461  SCIP_Real* gamma_, /**< coefficient of third coordinate */
462  SCIP_Real* delta /**< constant right-hand side */
463  );
464 
465 /* @} */
466 
467 /* @} */
468 
469 #ifdef __cplusplus
470 }
471 #endif
472 
473 #endif
SCIP_EXPRGRAPH * SCIPgetExprgraphNonlinear(SCIP *scip, SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPincludeNonlinconsUpgrade(SCIP *scip, SCIP_DECL_NONLINCONSUPGD((*nonlinconsupgd)), SCIP_DECL_EXPRGRAPHNODEREFORM((*nodereform)), int priority, SCIP_Bool active, const char *conshdlrname)
SCIP_RETCODE SCIPgetExprtreeCurvaturesNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_Bool checkcurv, SCIP_EXPRCURV **curvatures)
SCIP_RETCODE SCIPsetExprtreesNonlinear(SCIP *scip, SCIP_CONS *cons, int nexprtrees, SCIP_EXPRTREE **exprtrees, SCIP_Real *coefs)
SCIP_Real * SCIPgetLinearCoefsNonlinear(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPgetNlRowNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_NLROW **nlrow)
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
SCIP_RETCODE SCIPgetCurvatureNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_Bool checkcurv, SCIP_EXPRCURV *curvature)
SCIP_Real SCIPgetRhsNonlinear(SCIP *scip, SCIP_CONS *cons)
static GRAPHNODE ** active
int SCIPgetLinvarMayDecreaseNonlinear(SCIP *scip, SCIP_CONS *cons)
SCIP_EXPRTREE ** SCIPgetExprtreesNonlinear(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsBasicNonlinear2(SCIP *scip, SCIP_CONS **cons, const char *name, int nlinvars, SCIP_VAR **linvars, SCIP_Real *lincoefs, SCIP_EXPRGRAPHNODE *exprgraphnode, SCIP_Real lhs, SCIP_Real rhs)
SCIP_RETCODE SCIPaddExprtreesNonlinear(SCIP *scip, SCIP_CONS *cons, int nexprtrees, SCIP_EXPRTREE **exprtrees, SCIP_Real *coefs)
#define SCIP_DECL_EXPRGRAPHNODEREFORM(x)
int SCIPgetNExprtreesNonlinear(SCIP *scip, SCIP_CONS *cons)
int SCIPgetLinvarMayIncreaseNonlinear(SCIP *scip, SCIP_CONS *cons)
#define SCIP_DECL_NONLINCONSUPGD(x)
SCIP_RETCODE SCIPgetViolationNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Real *violation)
SCIP_Real * SCIPgetExprtreeCoefsNonlinear(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPaddLinearVarNonlinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real coef)
#define SCIP_Bool
Definition: def.h:61
SCIP_Real SCIPgetLhsNonlinear(SCIP *scip, SCIP_CONS *cons)
enum SCIP_ExprCurv SCIP_EXPRCURV
Definition: type_expr.h:93
SCIP_RETCODE SCIPcheckCurvatureNonlinear(SCIP *scip, SCIP_CONS *cons)
int SCIPgetNLinearVarsNonlinear(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsNonlinear2(SCIP *scip, SCIP_CONS **cons, const char *name, int nlinvars, SCIP_VAR **linvars, SCIP_Real *lincoefs, SCIP_EXPRGRAPHNODE *exprgraphnode, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
SCIP_RETCODE SCIPincludeConshdlrNonlinear(SCIP *scip)
#define SCIP_Real
Definition: def.h:149
SCIP_VAR ** SCIPgetLinearVarsNonlinear(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsNonlinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nlinvars, SCIP_VAR **linvars, SCIP_Real *lincoefs, int nexprtrees, SCIP_EXPRTREE **exprtrees, SCIP_Real *nonlincoefs, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
SCIP_RETCODE SCIPcomputeHyperplaneThreePoints(SCIP *scip, SCIP_Real a1, SCIP_Real a2, SCIP_Real a3, SCIP_Real b1, SCIP_Real b2, SCIP_Real b3, SCIP_Real c1, SCIP_Real c2, SCIP_Real c3, SCIP_Real *alpha, SCIP_Real *beta, SCIP_Real *gamma_, SCIP_Real *delta)
SCIP_EXPRGRAPHNODE * SCIPgetExprgraphNodeNonlinear(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsBasicNonlinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nlinvars, SCIP_VAR **linvars, SCIP_Real *lincoefs, int nexprtrees, SCIP_EXPRTREE **exprtrees, SCIP_Real *nonlincoefs, SCIP_Real lhs, SCIP_Real rhs)
SCIP callable library.