Scippy

SCIP

Solving Constraint Integer Programs

pub_expr.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 visit scip.zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file nlpi/pub_expr.h
17  * @brief public methods for expressions, expression trees, expression graphs, and related stuff
18  * @author Stefan Vigerske
19  * @author Thorsten Gellermann
20  */
21 
22 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
23 
24 #ifndef __NLPI_PUB_EXPR_H__
25 #define __NLPI_PUB_EXPR_H__
26 
27 #include "scip/def.h"
28 #include "scip/pub_message.h"
29 #include "scip/intervalarith.h"
30 #include "blockmemshell/memory.h"
31 #include "nlpi/type_expr.h"
32 #include "nlpi/type_exprinterpret.h"
33 
34 #ifdef NDEBUG
35 #include "nlpi/struct_expr.h"
36 #endif
37 
38 #ifdef __cplusplus
39 extern "C" {
40 #endif
41 
42 /**@name Expression curvature methods */
43 /**@{ */
44 
45 /** gives curvature for a sum of two functions with given curvature */
46 extern
47 SCIP_EXPRCURV SCIPexprcurvAdd(
48  SCIP_EXPRCURV curv1, /**< curvature of first summand */
49  SCIP_EXPRCURV curv2 /**< curvature of second summand */
50  );
51 
52 #ifdef NDEBUG
53 #define SCIPexprcurvAdd(curv1, curv2) ((SCIP_EXPRCURV) ((curv1) & (curv2)))
54 #endif
55 
56 /** gives the curvature for the negation of a function with given curvature */
57 extern
58 SCIP_EXPRCURV SCIPexprcurvNegate(
59  SCIP_EXPRCURV curvature /**< curvature of function */
60  );
61 
62 /** gives curvature for a functions with given curvature multiplied by a constant factor */
63 extern
64 SCIP_EXPRCURV SCIPexprcurvMultiply(
65  SCIP_Real factor, /**< constant factor */
66  SCIP_EXPRCURV curvature /**< curvature of other factor */
67  );
68 
69 /** gives curvature for base^exponent for given bounds and curvature of base-function and constant exponent */
70 extern
71 SCIP_EXPRCURV SCIPexprcurvPower(
72  SCIP_INTERVAL basebounds, /**< bounds on base function */
73  SCIP_EXPRCURV basecurv, /**< curvature of base function */
74  SCIP_Real exponent /**< exponent */
75  );
76 
77 /** gives curvature for a monomial with given curvatures and bounds for each factor */
78 extern
79 SCIP_EXPRCURV SCIPexprcurvMonomial(
80  int nfactors, /**< number of factors in monomial */
81  SCIP_Real* exponents, /**< exponents in monomial, or NULL if all 1.0 */
82  int* factoridxs, /**< indices of factors, or NULL if identity mapping */
83  SCIP_EXPRCURV* factorcurv, /**< curvature of each factor */
84  SCIP_INTERVAL* factorbounds /**< bounds of each factor */
85  );
86 
87 /** gives name as string for a curvature */
88 extern
89 const char* SCIPexprcurvGetName(
90  SCIP_EXPRCURV curv /**< curvature */
91  );
92 
93 /**@} */
94 
95 /**@name Expression operand methods */
96 /**@{ */
97 
98 /** gives the name of an operand */
99 extern
100 const char* SCIPexpropGetName(
101  SCIP_EXPROP op /**< expression operand */
102  );
103 
104 /** gives the number of children of a simple operand
105  * @return -1 for invalid operands and -2 for complex operands (those where the number of children depends on the expression)
106  */
107 extern
108 int SCIPexpropGetNChildren(
109  SCIP_EXPROP op /**< expression operand */
110  );
111 
112 /**@} */
113 
114 /**@name Expression methods */
115 /**@{ */
116 
117 /** gives operator of expression */
118 extern
119 SCIP_EXPROP SCIPexprGetOperator(
120  SCIP_EXPR* expr /**< expression */
121  );
122 
123 /** gives number of children of an expression */
124 extern
125 int SCIPexprGetNChildren(
126  SCIP_EXPR* expr /**< expression */
127  );
128 
129 /** gives pointer to array with children of an expression */
130 extern
131 SCIP_EXPR** SCIPexprGetChildren(
132  SCIP_EXPR* expr /**< expression */
133  );
134 
135 /** gives index belonging to a SCIP_EXPR_VARIDX or SCIP_EXPR_PARAM operand */
136 extern
137 int SCIPexprGetOpIndex(
138  SCIP_EXPR* expr /**< expression */
139  );
140 
141 /** gives real belonging to a SCIP_EXPR_CONST operand */
142 extern
143 SCIP_Real SCIPexprGetOpReal(
144  SCIP_EXPR* expr /**< expression */
145  );
146 
147 /** gives void* belonging to a complex operand */
148 extern
149 void* SCIPexprGetOpData(
150  SCIP_EXPR* expr /**< expression */
151  );
152 
153 /** gives exponent belonging to a SCIP_EXPR_REALPOWER expression */
154 extern
155 SCIP_Real SCIPexprGetRealPowerExponent(
156  SCIP_EXPR* expr /**< expression */
157  );
158 
159 /** gives exponent belonging to a SCIP_EXPR_INTPOWER expression */
160 extern
161 int SCIPexprGetIntPowerExponent(
162  SCIP_EXPR* expr /**< expression */
163  );
164 
165 /** gives exponent belonging to a SCIP_EXPR_SIGNPOWER expression */
166 extern
167 SCIP_Real SCIPexprGetSignPowerExponent(
168  SCIP_EXPR* expr /**< expression */
169  );
170 
171 /** gives linear coefficients belonging to a SCIP_EXPR_LINEAR expression */
172 extern
173 SCIP_Real* SCIPexprGetLinearCoefs(
174  SCIP_EXPR* expr /**< expression */
175  );
176 
177 /** gives constant belonging to a SCIP_EXPR_LINEAR expression */
178 extern
179 SCIP_Real SCIPexprGetLinearConstant(
180  SCIP_EXPR* expr /**< expression */
181  );
182 
183 /** gives quadratic elements belonging to a SCIP_EXPR_QUADRATIC expression */
184 extern
185 SCIP_QUADELEM* SCIPexprGetQuadElements(
186  SCIP_EXPR* expr /**< quadratic expression */
187  );
188 
189 /** gives constant belonging to a SCIP_EXPR_QUADRATIC expression */
190 extern
191 SCIP_Real SCIPexprGetQuadConstant(
192  SCIP_EXPR* expr /**< quadratic expression */
193  );
194 
195 /** gives linear coefficients belonging to a SCIP_EXPR_QUADRATIC expression
196  * can be NULL if all coefficients are 0.0 */
197 extern
198 SCIP_Real* SCIPexprGetQuadLinearCoefs(
199  SCIP_EXPR* expr /**< quadratic expression */
200  );
201 
202 /** gives number of quadratic elements belonging to a SCIP_EXPR_QUADRATIC expression */
203 extern
204 int SCIPexprGetNQuadElements(
205  SCIP_EXPR* expr /**< quadratic expression */
206  );
207 
208 /** gives the monomials belonging to a SCIP_EXPR_POLYNOMIAL expression */
209 extern
210 SCIP_EXPRDATA_MONOMIAL** SCIPexprGetMonomials(
211  SCIP_EXPR* expr /**< expression */
212  );
213 
214 /** gives the number of monomials belonging to a SCIP_EXPR_POLYNOMIAL expression */
215 extern
216 int SCIPexprGetNMonomials(
217  SCIP_EXPR* expr /**< expression */
218  );
219 
220 /** gives the constant belonging to a SCIP_EXPR_POLYNOMIAL expression */
221 extern
222 SCIP_Real SCIPexprGetPolynomialConstant(
223  SCIP_EXPR* expr /**< expression */
224  );
225 
226 /** gets coefficient of a monomial */
227 extern
228 SCIP_Real SCIPexprGetMonomialCoef(
229  SCIP_EXPRDATA_MONOMIAL* monomial /**< monomial */
230  );
231 
232 /** gets number of factors of a monomial */
233 extern
234 int SCIPexprGetMonomialNFactors(
235  SCIP_EXPRDATA_MONOMIAL* monomial /**< monomial */
236  );
237 
238 /** gets indices of children corresponding to factors of a monomial */
239 extern
240 int* SCIPexprGetMonomialChildIndices(
241  SCIP_EXPRDATA_MONOMIAL* monomial /**< monomial */
242  );
243 
244 /** gets exponents in factors of a monomial */
245 extern
246 SCIP_Real* SCIPexprGetMonomialExponents(
247  SCIP_EXPRDATA_MONOMIAL* monomial /**< monomial */
248  );
249 
250 /** gets user data of a user expression */
251 extern
252 SCIP_USEREXPRDATA* SCIPexprGetUserData(
253  SCIP_EXPR* expr
254  );
255 
256 /** indicates whether a user expression has the estimator callback defined */
257 extern
258 SCIP_Bool SCIPexprHasUserEstimator(
259  SCIP_EXPR* expr
260  );
261 
262 /** gives the evaluation capability of a user expression */
263 extern
264 SCIP_EXPRINTCAPABILITY SCIPexprGetUserEvalCapability(
265  SCIP_EXPR* expr
266  );
267 
268 #ifdef NDEBUG
269 
270 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
271  * speed up the algorithms.
272  */
273 
274 #define SCIPexprGetOperator(expr) (expr)->op
275 #define SCIPexprGetNChildren(expr) (expr)->nchildren
276 #define SCIPexprGetChildren(expr) (expr)->children
277 #define SCIPexprGetOpIndex(expr) (expr)->data.intval
278 #define SCIPexprGetOpReal(expr) (expr)->data.dbl
279 #define SCIPexprGetOpData(expr) (expr)->data.data
280 #define SCIPexprGetRealPowerExponent(expr) (expr)->data.dbl
281 #define SCIPexprGetIntPowerExponent(expr) (expr)->data.intval
282 #define SCIPexprGetSignPowerExponent(expr) (expr)->data.dbl
283 #define SCIPexprGetLinearCoefs(expr) ((SCIP_Real*)(expr)->data.data)
284 #define SCIPexprGetLinearConstant(expr) (((SCIP_Real*)(expr)->data.data)[(expr)->nchildren])
285 #define SCIPexprGetQuadElements(expr) ((SCIP_EXPRDATA_QUADRATIC*)(expr)->data.data)->quadelems
286 #define SCIPexprGetQuadConstant(expr) ((SCIP_EXPRDATA_QUADRATIC*)(expr)->data.data)->constant
287 #define SCIPexprGetQuadLinearCoefs(expr) ((SCIP_EXPRDATA_QUADRATIC*)(expr)->data.data)->lincoefs
288 #define SCIPexprGetNQuadElements(expr) ((SCIP_EXPRDATA_QUADRATIC*)(expr)->data.data)->nquadelems
289 #define SCIPexprGetMonomials(expr) ((SCIP_EXPRDATA_POLYNOMIAL*)(expr)->data.data)->monomials
290 #define SCIPexprGetNMonomials(expr) ((SCIP_EXPRDATA_POLYNOMIAL*)(expr)->data.data)->nmonomials
291 #define SCIPexprGetPolynomialConstant(expr) ((SCIP_EXPRDATA_POLYNOMIAL*)(expr)->data.data)->constant
292 #define SCIPexprGetMonomialCoef(monomial) (monomial)->coef
293 #define SCIPexprGetMonomialNFactors(monomial) (monomial)->nfactors
294 #define SCIPexprGetMonomialChildIndices(monomial) (monomial)->childidxs
295 #define SCIPexprGetMonomialExponents(monomial) (monomial)->exponents
296 #define SCIPexprGetUserData(expr) ((SCIP_EXPRDATA_USER*)(expr)->data.data)->userdata
297 #define SCIPexprHasUserEstimator(expr) (((SCIP_EXPRDATA_USER*)expr->data.data)->estimate != NULL)
298 #define SCIPexprGetUserEvalCapability(expr) (((SCIP_EXPRDATA_USER*)expr->data.data)->evalcapability)
299 
300 #endif
301 
302 /** creates a simple expression */
303 extern
304 SCIP_RETCODE SCIPexprCreate(
305  BMS_BLKMEM* blkmem, /**< block memory data structure */
306  SCIP_EXPR** expr, /**< pointer to buffer for expression address */
307  SCIP_EXPROP op, /**< operand of expression */
308  ... /**< arguments of operand */
309  );
310 
311 /** copies an expression including its children */
312 extern
313 SCIP_RETCODE SCIPexprCopyDeep(
314  BMS_BLKMEM* blkmem, /**< block memory data structure */
315  SCIP_EXPR** targetexpr, /**< buffer to store pointer to copied expression */
316  SCIP_EXPR* sourceexpr /**< expression to copy */
317  );
318 
319 /** frees an expression including its children */
320 extern
321 void SCIPexprFreeDeep(
322  BMS_BLKMEM* blkmem, /**< block memory data structure */
323  SCIP_EXPR** expr /**< pointer to expression to free */
324  );
325 
326 /** frees an expression but not its children */
327 extern
328 void SCIPexprFreeShallow(
329  BMS_BLKMEM* blkmem, /**< block memory data structure */
330  SCIP_EXPR** expr /**< pointer to expression to free */
331  );
332 
333 /** creates an expression from the addition of two given expression, with coefficients, and a constant
334  *
335  * the given expressions may be modified or freed, otherwise it will be used a child expression
336  * favors creation and maintaining of SCIP_EXPR_LINEAR over SCIP_EXPR_PLUS or SCIP_EXPR_SUM
337  */
338 extern
339 SCIP_RETCODE SCIPexprAdd(
340  BMS_BLKMEM* blkmem, /**< block memory data structure */
341  SCIP_EXPR** expr, /**< pointer to store pointer to created expression */
342  SCIP_Real coef1, /**< coefficient of first term */
343  SCIP_EXPR* term1, /**< expression of first term, or NULL */
344  SCIP_Real coef2, /**< coefficient of second term */
345  SCIP_EXPR* term2, /**< expression of second term, or NULL */
346  SCIP_Real constant /**< constant term to add */
347  );
348 
349 /** creates an expression from the multiplication of an expression with a constant
350  *
351  * the given expressions may be modified or freed, otherwise it will be used a child expression
352  * favors creation of SCIP_EXPR_LINEAR over SCIP_EXPR_MUP or SCIP_EXPR_PROD
353  */
354 extern
355 SCIP_RETCODE SCIPexprMulConstant(
356  BMS_BLKMEM* blkmem, /**< block memory data structure */
357  SCIP_EXPR** expr, /**< buffer to store pointer to created expression */
358  SCIP_EXPR* term, /**< term to multiply by factor */
359  SCIP_Real factor /**< factor */
360  );
361 
362 /** creates a SCIP_EXPR_LINEAR expression that is (affine) linear in its children: constant + sum_i coef_i child_i */
363 extern
364 SCIP_RETCODE SCIPexprCreateLinear(
365  BMS_BLKMEM* blkmem, /**< block memory data structure */
366  SCIP_EXPR** expr, /**< pointer to buffer for expression address */
367  int nchildren, /**< number of children */
368  SCIP_EXPR** children, /**< children of expression */
369  SCIP_Real* coefs, /**< coefficients of children */
370  SCIP_Real constant /**< constant part */
371  );
372 
373 /** adds new terms to a linear expression */
374 extern
375 SCIP_RETCODE SCIPexprAddToLinear(
376  BMS_BLKMEM* blkmem, /**< block memory */
377  SCIP_EXPR* expr, /**< linear expression */
378  int nchildren, /**< number of children to add */
379  SCIP_Real* coefs, /**< coefficients of additional children */
380  SCIP_EXPR** children, /**< additional children expressions */
381  SCIP_Real constant /**< constant to add */
382  );
383 
384 /** creates a SCIP_EXPR_QUADRATIC expression: constant + sum_i coef_i child_i + sum_i coef_i child1_i child2_i */
385 SCIP_RETCODE SCIPexprCreateQuadratic(
386  BMS_BLKMEM* blkmem, /**< block memory data structure */
387  SCIP_EXPR** expr, /**< pointer to buffer for expression address */
388  int nchildren, /**< number of children */
389  SCIP_EXPR** children, /**< children of expression */
390  SCIP_Real constant, /**< constant */
391  SCIP_Real* lincoefs, /**< linear coefficients of children, or NULL if all 0.0 */
392  int nquadelems, /**< number of quadratic elements */
393  SCIP_QUADELEM* quadelems /**< quadratic elements specifying coefficients and child indices */
394  );
395 
396 /** ensures that quadratic elements of a quadratic expression are sorted */
397 extern
398 void SCIPexprSortQuadElems(
399  SCIP_EXPR* expr /**< quadratic expression */
400  );
401 
402 /** creates a SCIP_EXPR_POLYNOMIAL expression from an array of monomials: constant + sum_i monomial_i */
403 extern
404 SCIP_RETCODE SCIPexprCreatePolynomial(
405  BMS_BLKMEM* blkmem, /**< block memory data structure */
406  SCIP_EXPR** expr, /**< pointer to buffer for expression address */
407  int nchildren, /**< number of children */
408  SCIP_EXPR** children, /**< children of expression */
409  int nmonomials, /**< number of monomials */
410  SCIP_EXPRDATA_MONOMIAL** monomials, /**< monomials */
411  SCIP_Real constant, /**< constant part */
412  SCIP_Bool copymonomials /**< should monomials by copied or ownership be assumed? */
413  );
414 
415 /** adds an array of monomials to a SCIP_EXPR_POLYNOMIAL expression */
416 extern
417 SCIP_RETCODE SCIPexprAddMonomials(
418  BMS_BLKMEM* blkmem, /**< block memory of expression */
419  SCIP_EXPR* expr, /**< expression */
420  int nmonomials, /**< number of monomials to add */
421  SCIP_EXPRDATA_MONOMIAL** monomials, /**< the monomials to add */
422  SCIP_Bool copymonomials /**< should monomials by copied or ownership be assumed? */
423  );
424 
425 /** changes the constant in a SCIP_EXPR_POLYNOMIAL expression */
426 extern
427 void SCIPexprChgPolynomialConstant(
428  SCIP_EXPR* expr, /**< expression */
429  SCIP_Real constant /**< new value for constant */
430  );
431 
432 /** multiplies each summand of a polynomial by a given constant */
433 extern
434 void SCIPexprMultiplyPolynomialByConstant(
435  BMS_BLKMEM* blkmem, /**< block memory */
436  SCIP_EXPR* expr, /**< polynomial expression */
437  SCIP_Real factor /**< constant factor */
438  );
439 
440 /** multiplies each summand of a polynomial by a given monomial */
441 extern
442 SCIP_RETCODE SCIPexprMultiplyPolynomialByMonomial(
443  BMS_BLKMEM* blkmem, /**< block memory */
444  SCIP_EXPR* expr, /**< polynomial expression */
445  SCIP_EXPRDATA_MONOMIAL* factor, /**< monomial factor */
446  int* childmap /**< map children in factor to children in expr, or NULL for 1:1 */
447  );
448 
449 /** multiplies this polynomial by a polynomial
450  * factor needs to be different from expr */
451 extern
452 SCIP_RETCODE SCIPexprMultiplyPolynomialByPolynomial(
453  BMS_BLKMEM* blkmem, /**< block memory */
454  SCIP_EXPR* expr, /**< polynomial expression */
455  SCIP_EXPR* factor, /**< polynomial factor */
456  int* childmap /**< map children in factor to children in expr, or NULL for 1:1 */
457  );
458 
459 /** takes a power of the polynomial
460  * exponent need to be an integer
461  * polynomial need to be a monomial, if exponent is negative
462  */
463 extern
464 SCIP_RETCODE SCIPexprPolynomialPower(
465  BMS_BLKMEM* blkmem, /**< block memory */
466  SCIP_EXPR* expr, /**< polynomial expression */
467  int exponent /**< exponent of power operation */
468  );
469 
470 /** merges monomials in a polynomial expression that differ only in coefficient into a single monomial
471  * eliminates monomials with coefficient between -eps and eps
472  */
473 extern
474 void SCIPexprMergeMonomials(
475  BMS_BLKMEM* blkmem, /**< block memory */
476  SCIP_EXPR* expr, /**< polynomial expression */
477  SCIP_Real eps, /**< threshold under which numbers are treat as zero */
478  SCIP_Bool mergefactors /**< whether to merge factors in monomials too */
479  );
480 
481 /** creates a monomial */
482 extern
483 SCIP_RETCODE SCIPexprCreateMonomial(
484  BMS_BLKMEM* blkmem, /**< block memory */
485  SCIP_EXPRDATA_MONOMIAL** monomial, /**< buffer where to store pointer to new monomial */
486  SCIP_Real coef, /**< coefficient of monomial */
487  int nfactors, /**< number of factors in monomial */
488  int* childidxs, /**< indices of children corresponding to factors, or NULL if identity */
489  SCIP_Real* exponents /**< exponent in each factor, or NULL if all 1.0 */
490  );
491 
492 /** frees a monomial */
493 extern
494 void SCIPexprFreeMonomial(
495  BMS_BLKMEM* blkmem, /**< block memory */
496  SCIP_EXPRDATA_MONOMIAL** monomial /**< pointer to monomial that should be freed */
497  );
498 
499 /** ensures that factors in a monomial are sorted */
500 extern
501 void SCIPexprSortMonomialFactors(
502  SCIP_EXPRDATA_MONOMIAL* monomial /**< monomial */
503  );
504 
505 /** finds a factor corresponding to a given child index in a monomial
506  * note that if the factors have not been merged, the position of some factor corresponding to a given child is given
507  * returns TRUE if a factor is found, FALSE if not
508  */
509 extern
510 SCIP_Bool SCIPexprFindMonomialFactor(
511  SCIP_EXPRDATA_MONOMIAL* monomial, /**< monomial */
512  int childidx, /**< index of the child which factor to search for */
513  int* pos /**< buffer to store position of factor */
514  );
515 
516 /** checks if two monomials are equal */
517 extern
518 SCIP_Bool SCIPexprAreMonomialsEqual(
519  SCIP_EXPRDATA_MONOMIAL* monomial1, /**< first monomial */
520  SCIP_EXPRDATA_MONOMIAL* monomial2, /**< second monomial */
521  SCIP_Real eps /**< threshold under which numbers are treated as 0.0 */
522  );
523 
524 /** adds factors to a monomial */
525 extern
526 SCIP_RETCODE SCIPexprAddMonomialFactors(
527  BMS_BLKMEM* blkmem, /**< block memory */
528  SCIP_EXPRDATA_MONOMIAL* monomial, /**< monomial */
529  int nfactors, /**< number of factors to add */
530  int* childidxs, /**< indices of children corresponding to factors */
531  SCIP_Real* exponents /**< exponent in each factor */
532  );
533 
534 /** changes coefficient of monomial */
535 extern
536 void SCIPexprChgMonomialCoef(
537  SCIP_EXPRDATA_MONOMIAL* monomial, /**< monomial */
538  SCIP_Real newcoef /**< new coefficient */
539  );
540 
541 /** multiplies a monomial with a monomial */
542 extern
543 SCIP_RETCODE SCIPexprMultiplyMonomialByMonomial(
544  BMS_BLKMEM* blkmem, /**< block memory */
545  SCIP_EXPRDATA_MONOMIAL* monomial, /**< monomial */
546  SCIP_EXPRDATA_MONOMIAL* factor, /**< factor monomial */
547  int* childmap /**< map to apply to children in factor, or NULL for 1:1 */
548  );
549 
550 /** replaces the monomial by a power of the monomial
551  * allows only integers as exponent
552  */
553 extern
554 void SCIPexprMonomialPower(
555  SCIP_EXPRDATA_MONOMIAL* monomial, /**< monomial */
556  int exponent /**< integer exponent of power operation */
557  );
558 
559 /** merges factors that correspond to the same child by adding exponents
560  * eliminates factors with exponent between -eps and eps
561  */
562 extern
563 void SCIPexprMergeMonomialFactors(
564  SCIP_EXPRDATA_MONOMIAL* monomial, /**< monomial */
565  SCIP_Real eps /**< threshold under which numbers are treated as 0.0 */
566  );
567 
568 /** ensures that monomials of a polynomial are sorted */
569 extern
570 void SCIPexprSortMonomials(
571  SCIP_EXPR* expr /**< polynomial expression */
572  );
573 
574 /** creates a user expression */
575 extern
576 SCIP_RETCODE SCIPexprCreateUser(
577  BMS_BLKMEM* blkmem, /**< block memory data structure */
578  SCIP_EXPR** expr, /**< pointer to buffer for expression address */
579  int nchildren, /**< number of children */
580  SCIP_EXPR** children, /**< children of expression */
581  SCIP_USEREXPRDATA* data, /**< user data for expression, expression assumes ownership */
582  SCIP_EXPRINTCAPABILITY evalcapability, /**< capability of evaluation functions (partially redundant, currently) */
583  SCIP_DECL_USEREXPREVAL ((*eval)), /**< evaluation function */
584  SCIP_DECL_USEREXPRINTEVAL ((*inteval)), /**< interval evaluation function, or NULL if not implemented */
585  SCIP_DECL_USEREXPRCURV ((*curv)), /**< curvature check function */
586  SCIP_DECL_USEREXPRPROP ((*prop)), /**< interval propagation function, or NULL if not implemented */
587  SCIP_DECL_USEREXPRESTIMATE ((*estimate)), /**< estimation function, or NULL if convex, concave, or not implemented */
588  SCIP_DECL_USEREXPRCOPYDATA ((*copydata)), /**< expression data copy function, or NULL if nothing to copy */
589  SCIP_DECL_USEREXPRFREEDATA ((*freedata)), /**< expression data free function, or NULL if nothing to free */
590  SCIP_DECL_USEREXPRPRINT ((*print)) /**< expression print function, or NULL for default string "user" */
591  );
592 
593 /** indicates whether the expression contains a SCIP_EXPR_PARAM */
594 extern
595 SCIP_Bool SCIPexprHasParam(
596  SCIP_EXPR* expr /**< expression */
597  );
598 
599 /** gets maximal degree of expression, or SCIP_EXPR_DEGREEINFINITY if not a polynomial */
600 extern
601 SCIP_RETCODE SCIPexprGetMaxDegree(
602  SCIP_EXPR* expr, /**< expression */
603  int* maxdegree /**< buffer to store maximal degree */
604  );
605 
606 /** counts usage of variables in expression */
607 extern
608 void SCIPexprGetVarsUsage(
609  SCIP_EXPR* expr, /**< expression to update */
610  int* varsusage /**< array with counters of variable usage */
611  );
612 
613 /** compares whether two expressions are the same
614  * inconclusive, i.e., may give FALSE even if expressions are equivalent (x*y != y*x)
615  */
616 extern
617 SCIP_Bool SCIPexprAreEqual(
618  SCIP_EXPR* expr1, /**< first expression */
619  SCIP_EXPR* expr2, /**< second expression */
620  SCIP_Real eps /**< threshold under which numbers are assumed to be zero */
621  );
622 
623 /** aims at simplifying an expression and splitting of a linear expression
624  * if linear variables are split off, expression interpreter data, if stored in the tree, is freed
625  */
626 extern
627 SCIP_RETCODE SCIPexprSimplify(
628  BMS_BLKMEM* blkmem, /**< block memory data structure */
629  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
630  SCIP_EXPR* expr, /**< expression */
631  SCIP_Real eps, /**< threshold, under which positive values are treat as 0 */
632  int maxexpansionexponent,/**< maximal exponent for which we still expand non-monomial polynomials */
633  int nvars, /**< number of variables in expression */
634  int* nlinvars, /**< buffer to store number of linear variables in linear part, or NULL if linear part should not be separated */
635  int* linidxs, /**< array to store indices of variables in expression tree which belong to linear part, or NULL */
636  SCIP_Real* lincoefs /**< array to store coefficients of linear part, or NULL */
637  );
638 
639 /** evaluates an expression w.r.t. given values for children expressions */
640 extern
641 SCIP_RETCODE SCIPexprEvalShallow(
642  SCIP_EXPR* expr, /**< expression */
643  SCIP_Real* argvals, /**< values for children, can be NULL if the expression has no children */
644  SCIP_Real* varvals, /**< values for variables, can be NULL if the expression operand is not a variable */
645  SCIP_Real* param, /**< values for parameters, can be NULL if the expression operand is not a parameter */
646  SCIP_Real* val /**< buffer to store value */
647  );
648 
649 /** evaluates an expression w.r.t. a point */
650 extern
651 SCIP_RETCODE SCIPexprEval(
652  SCIP_EXPR* expr, /**< expression */
653  SCIP_Real* varvals, /**< values for variables, can be NULL if the expression is constant */
654  SCIP_Real* param, /**< values for parameters, can be NULL if the expression is not parameterized */
655  SCIP_Real* val /**< buffer to store value */
656  );
657 
658 /** evaluates an expression w.r.t. given interval values for children expressions */
659 extern
660 SCIP_RETCODE SCIPexprEvalIntShallow(
661  SCIP_EXPR* expr, /**< expression */
662  SCIP_Real infinity, /**< value to use for infinity */
663  SCIP_INTERVAL* argvals, /**< interval values for children, can be NULL if the expression has no children */
664  SCIP_INTERVAL* varvals, /**< interval values for variables, can be NULL if the expression is constant */
665  SCIP_Real* param, /**< values for parameters, can be NULL if the expression is not parameterized */
666  SCIP_INTERVAL* val /**< buffer to store value */
667  );
668 
669 /** evaluates an expression w.r.t. an interval */
670 extern
671 SCIP_RETCODE SCIPexprEvalInt(
672  SCIP_EXPR* expr, /**< expression */
673  SCIP_Real infinity, /**< value to use for infinity */
674  SCIP_INTERVAL* varvals, /**< interval values for variables, can be NULL if the expression is constant */
675  SCIP_Real* param, /**< values for parameters, can be NULL if the expression is not parameterized */
676  SCIP_INTERVAL* val /**< buffer to store value */
677  );
678 
679 /** evaluates a user expression w.r.t. given values for children expressions */
680 extern
681 SCIP_RETCODE SCIPexprEvalUser(
682  SCIP_EXPR* expr, /**< expression */
683  SCIP_Real* argvals, /**< values for children */
684  SCIP_Real* val, /**< buffer to store function value */
685  SCIP_Real* gradient, /**< buffer to store gradient values, or NULL if not requested */
686  SCIP_Real* hessian /**< buffer to store values of full Hessian, or NULL if not requested */
687  );
688 
689 /** evaluates a user expression w.r.t. an interval */
690 extern
691 SCIP_RETCODE SCIPexprEvalIntUser(
692  SCIP_EXPR* expr, /**< expression */
693  SCIP_Real infinity, /**< value to use for infinity */
694  SCIP_INTERVAL* argvals, /**< values for children */
695  SCIP_INTERVAL* val, /**< buffer to store value */
696  SCIP_INTERVAL* gradient, /**< buffer to store gradient values, or NULL if not requested */
697  SCIP_INTERVAL* hessian /**< buffer to store values of full Hessian, or NULL if not requested */
698  );
699 
700 /** tries to determine the curvature type of an expression w.r.t. given variable domains */
701 extern
702 SCIP_RETCODE SCIPexprCheckCurvature(
703  SCIP_EXPR* expr, /**< expression to check */
704  SCIP_Real infinity, /**< value to use for infinity */
705  SCIP_INTERVAL* varbounds, /**< domains of variables */
706  SCIP_Real* param, /**< values for parameters, can be NULL if the expression is not parameterized */
707  SCIP_EXPRCURV* curv, /**< buffer to store curvature of expression */
708  SCIP_INTERVAL* bounds /**< buffer to store bounds on expression */
709  );
710 
711 /** under-/overestimates a user expression w.r.t. to given values and bounds for children expressions */
712 extern
713 SCIP_RETCODE SCIPexprEstimateUser(
714  SCIP_EXPR* expr, /**< expression */
715  SCIP_Real infinity, /**< value to use for infinity */
716  SCIP_Real* argvals, /**< values for children */
717  SCIP_INTERVAL* argbounds, /**< bounds for children */
718  SCIP_Bool overestimate, /**< whether to overestimate the expression */
719  SCIP_Real* coeffs, /**< buffer to store the linear coefficients for each child expression that gives a valid under-/overestimator */
720  SCIP_Real* constant, /**< buffer to store the constant value of the linear under-/overestimator */
721  SCIP_Bool* success /**< buffer to store whether an estimator was successfully computed */
722 );
723 
724 
725 /** substitutes variables (SCIP_EXPR_VARIDX) by expressions
726  * Note that only the children of the given expr are checked!
727  * A variable with index i is replaced by a copy of substexprs[i], if that latter is not NULL
728  * if substexprs[i] == NULL, then the variable expression i is not touched
729  */
730 extern
731 SCIP_RETCODE SCIPexprSubstituteVars(
732  BMS_BLKMEM* blkmem, /**< block memory data structure */
733  SCIP_EXPR* expr, /**< expression, which of the children may be replaced */
734  SCIP_EXPR** substexprs /**< array of substitute expressions; single entries can be NULL */
735  );
736 
737 /** updates variable indices in expression tree */
738 extern
739 void SCIPexprReindexVars(
740  SCIP_EXPR* expr, /**< expression to update */
741  int* newindices /**< new indices of variables */
742  );
743 
744 /** updates parameter indices in expression tree */
745 extern
746 void SCIPexprReindexParams(
747  SCIP_EXPR* expr, /**< expression to update */
748  int* newindices /**< new indices of variables */
749  );
750 
751 /** prints an expression */
752 extern
753 void SCIPexprPrint(
754  SCIP_EXPR* expr, /**< expression */
755  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
756  FILE* file, /**< file for printing, or NULL for stdout */
757  const char** varnames, /**< names of variables, or NULL for default names */
758  const char** paramnames, /**< names of parameters, or NULL for default names */
759  SCIP_Real* paramvals /**< values of parameters, or NULL for not printing */
760  );
761 
762 /** parses an expression from a string */
763 extern
764 SCIP_RETCODE SCIPexprParse(
765  BMS_BLKMEM* blkmem, /**< block memory data structure */
766  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
767  SCIP_EXPR** expr, /**< buffer to store pointer to created expression */
768  const char* str, /**< pointer to the string to be parsed */
769  const char* lastchar, /**< pointer to the last char of str that should be parsed */
770  int* nvars, /**< buffer to store number of variables */
771  int* varnames, /**< buffer to store variable names, prefixed by index (as int) */
772  int varnameslength /**< length of the varnames buffer array */
773  );
774 
775 /**@} */
776 
777 /**@name Expression tree methods */
778 /**@{ */
779 
780 /** returns root expression of an expression tree */
781 extern
782 SCIP_EXPR* SCIPexprtreeGetRoot(
783  SCIP_EXPRTREE* tree /**< expression tree */
784  );
785 
786 /** returns number of variables in expression tree */
787 extern
788 int SCIPexprtreeGetNVars(
789  SCIP_EXPRTREE* tree /**< expression tree */
790  );
791 
792 /** returns number of parameters in expression tree */
793 extern
794 int SCIPexprtreeGetNParams(
795  SCIP_EXPRTREE* tree /**< expression tree */
796  );
797 
798 /** returns values of parameters or NULL if none */
799 extern
800 SCIP_Real* SCIPexprtreeGetParamVals(
801  SCIP_EXPRTREE* tree /**< expression tree */
802  );
803 
804 /** sets value of a single parameter in expression tree */
805 extern
806 void SCIPexprtreeSetParamVal(
807  SCIP_EXPRTREE* tree, /**< expression tree */
808  int paramidx, /**< index of parameter */
809  SCIP_Real paramval /**< new value of parameter */
810  );
811 
812 /** gets data of expression tree interpreter, or NULL if not set */
813 extern
814 SCIP_EXPRINTDATA* SCIPexprtreeGetInterpreterData(
815  SCIP_EXPRTREE* tree /**< expression tree */
816  );
817 
818 /** sets data of expression tree interpreter */
819 extern
820 void SCIPexprtreeSetInterpreterData(
821  SCIP_EXPRTREE* tree, /**< expression tree */
822  SCIP_EXPRINTDATA* interpreterdata /**< expression interpreter data */
823  );
824 
825 /** frees data of expression tree interpreter, if any */
826 extern
827 SCIP_RETCODE SCIPexprtreeFreeInterpreterData(
828  SCIP_EXPRTREE* tree /**< expression tree */
829  );
830 
831 /** indicates whether there are parameterized constants (SCIP_EXPR_PARAM) in expression tree */
832 extern
833 SCIP_Bool SCIPexprtreeHasParam(
834  SCIP_EXPRTREE* tree /**< expression tree */
835  );
836 
837 /** Gives maximal degree of expression in expression tree.
838  * If constant expression, gives 0,
839  * if linear expression, gives 1,
840  * if polynomial expression, gives its maximal degree,
841  * otherwise (nonpolynomial nonconstant expressions) gives at least SCIP_EXPR_DEGREEINFINITY.
842  */
843 extern
844 SCIP_RETCODE SCIPexprtreeGetMaxDegree(
845  SCIP_EXPRTREE* tree, /**< expression tree */
846  int* maxdegree /**< buffer to store maximal degree */
847  );
848 
849 /** evaluates an expression tree w.r.t. a point */
850 extern
851 SCIP_RETCODE SCIPexprtreeEval(
852  SCIP_EXPRTREE* tree, /**< expression tree */
853  SCIP_Real* varvals, /**< values for variables */
854  SCIP_Real* val /**< buffer to store expression tree value */
855  );
856 
857 /** evaluates an expression tree w.r.t. an interval */
858 extern
859 SCIP_RETCODE SCIPexprtreeEvalInt(
860  SCIP_EXPRTREE* tree, /**< expression tree */
861  SCIP_Real infinity, /**< value for infinity */
862  SCIP_INTERVAL* varvals, /**< intervals for variables */
863  SCIP_INTERVAL* val /**< buffer to store expression tree value */
864  );
865 
866 /** prints an expression tree */
867 extern
868 void SCIPexprtreePrint(
869  SCIP_EXPRTREE* tree, /**< expression tree */
870  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
871  FILE* file, /**< file for printing, or NULL for stdout */
872  const char** varnames, /**< names of variables, or NULL for default names */
873  const char** paramnames /**< names of parameters, or NULL for default names */
874  );
875 
876 #ifdef NDEBUG
877 
878 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
879  * speed up the algorithms.
880  */
881 
882 #define SCIPexprtreeGetRoot(tree) (tree)->root
883 #define SCIPexprtreeGetNVars(tree) (tree)->nvars
884 #define SCIPexprtreeGetNParams(tree) (tree)->nparams
885 #define SCIPexprtreeGetParamVals(tree) (tree)->params
886 #define SCIPexprtreeSetParamVal(tree, paramidx, paramval) do { (tree)->params[(paramidx)] = paramval; } while (FALSE)
887 #define SCIPexprtreeGetInterpreterData(tree) (tree)->interpreterdata
888 #define SCIPexprtreeSetInterpreterData(tree, newinterpreterdata) do { (tree)->interpreterdata = newinterpreterdata; } while (FALSE)
889 #define SCIPexprtreeFreeInterpreterData(tree) ((tree)->interpreterdata != NULL ? SCIPexprintFreeData(&(tree)->interpreterdata) : SCIP_OKAY)
890 #define SCIPexprtreeHasParam(tree) SCIPexprHasParam((tree)->root)
891 #define SCIPexprtreeGetMaxDegree(tree, maxdegree) SCIPexprGetMaxDegree((tree)->root, maxdegree)
892 #define SCIPexprtreeEval(tree, varvals, val) SCIPexprEval((tree)->root, varvals, (tree)->params, val)
893 #define SCIPexprtreeEvalInt(tree, infinity, varvals, val) SCIPexprEvalInt((tree)->root, infinity, varvals, (tree)->params, val)
894 #define SCIPexprtreePrint(tree, messagehdlr, file, varnames, paramnames) SCIPexprPrint((tree)->root, messagehdlr, file, varnames, paramnames, (tree)->params)
895 
896 #endif
897 
898 /** creates an expression tree */
899 extern
900 SCIP_RETCODE SCIPexprtreeCreate(
901  BMS_BLKMEM* blkmem, /**< block memory data structure */
902  SCIP_EXPRTREE** tree, /**< buffer to store address of created expression tree */
903  SCIP_EXPR* root, /**< pointer to root expression, not copied deep !, can be NULL */
904  int nvars, /**< number of variables in variable mapping */
905  int nparams, /**< number of parameters in expression */
906  SCIP_Real* params /**< values for parameters, or NULL (if NULL but nparams > 0, then params is initialized with zeros) */
907  );
908 
909 /** copies an expression tree */
910 extern
911 SCIP_RETCODE SCIPexprtreeCopy(
912  BMS_BLKMEM* blkmem, /**< block memory that should be used in new expression tree */
913  SCIP_EXPRTREE** targettree, /**< buffer to store address of copied expression tree */
914  SCIP_EXPRTREE* sourcetree /**< expression tree to copy */
915  );
916 
917 /** frees an expression tree */
918 extern
919 SCIP_RETCODE SCIPexprtreeFree(
920  SCIP_EXPRTREE** tree /**< pointer to expression tree that is freed */
921  );
922 
923 /** sets number and values of all parameters in expression tree */
924 extern
925 SCIP_RETCODE SCIPexprtreeSetParams(
926  SCIP_EXPRTREE* tree, /**< expression tree */
927  int nparams, /**< number of parameters */
928  SCIP_Real* paramvals /**< values of parameters, can be NULL if nparams == 0 */
929  );
930 
931 /** gives the number of usages for each variable in the expression tree */
932 extern
933 void SCIPexprtreeGetVarsUsage(
934  SCIP_EXPRTREE* tree, /**< expression tree */
935  int* varsusage /**< array where to store for each variable how often it is used in the tree */
936  );
937 
938 /** aims at simplifying an expression and splitting of a linear expression
939  * if linear variables are split off, expression interpreter data, if stored in the tree, is freed
940  */
941 extern
942 SCIP_RETCODE SCIPexprtreeSimplify(
943  SCIP_EXPRTREE* tree, /**< expression tree */
944  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
945  SCIP_Real eps, /**< threshold, under which positive values are treat as 0 */
946  int maxexpansionexponent,/**< maximal exponent for which we still expand non-monomial polynomials */
947  int* nlinvars, /**< buffer to store number of linear variables in linear part, or NULL if linear part should not be separated */
948  int* linidxs, /**< array to store indices of variables in expression tree which belong to linear part, or NULL */
949  SCIP_Real* lincoefs /**< array to store coefficients of linear part, or NULL */
950  );
951 
952 /** adds an expression to the root expression of the tree
953  *
954  * The root is replaced with an SCIP_EXPR_PLUS expression which has the previous root and the given expression as children
955  * If no root existed yet, then the root is set to the given expression (or a copy of it).
956  */
957 extern
958 SCIP_RETCODE SCIPexprtreeAddExpr(
959  SCIP_EXPRTREE* tree, /**< expression tree */
960  SCIP_EXPR* expr, /**< expression to add to tree */
961  SCIP_Bool copyexpr /**< whether expression should be copied */
962  );
963 
964 /** tries to determine the curvature type of an expression tree w.r.t. given variable domains */
965 extern
966 SCIP_RETCODE SCIPexprtreeCheckCurvature(
967  SCIP_EXPRTREE* tree, /**< expression tree */
968  SCIP_Real infinity, /**< value for infinity */
969  SCIP_INTERVAL* varbounds, /**< domains of variables */
970  SCIP_EXPRCURV* curv, /**< buffer to store curvature of expression */
971  SCIP_INTERVAL* bounds /**< buffer to store bounds on expression, or NULL if not needed */
972  );
973 
974 /** substitutes variables (SCIP_EXPR_VARIDX) in an expression tree by expressions
975  * A variable with index i is replaced by a copy of substexprs[i], if that latter is not NULL
976  * if substexprs[i] == NULL, then the variable expression i is not touched
977  */
978 extern
979 SCIP_RETCODE SCIPexprtreeSubstituteVars(
980  SCIP_EXPRTREE* tree, /**< expression tree */
981  SCIP_EXPR** substexprs /**< array of substitute expressions; single entries can be NULL */
982  );
983 
984 /**@} */
985 
986 /**@name Quadratic element methods */
987 /**@{ */
988 
989 /** sorts an array of quadratic elements
990  * The elements are sorted such that the first index is increasing and
991  * such that among elements with the same first index, the second index is increasing.
992  * For elements with same first and second index, the order is not defined.
993  */
994 extern
995 void SCIPquadelemSort(
996  SCIP_QUADELEM* quadelems, /**< array of quadratic elements */
997  int nquadelems /**< number of quadratic elements */
998  );
999 
1000 /** Finds an index pair in a sorted array of quadratic elements.
1001  * If (idx1,idx2) is found in quadelems, then returns TRUE and stores position of quadratic element in *pos.
1002  * If (idx1,idx2) is not found in quadelems, then returns FALSE and stores position where a quadratic element with these indices would be inserted in *pos.
1003  * Assumes that idx1 <= idx2.
1004  */
1005 extern
1006 SCIP_Bool SCIPquadelemSortedFind(
1007  SCIP_QUADELEM* quadelems, /**< array of quadratic elements */
1008  int idx1, /**< index of first variable in element to search for */
1009  int idx2, /**< index of second variable in element to search for */
1010  int nquadelems, /**< number of quadratic elements in array */
1011  int* pos /**< buffer to store position of found quadratic element, or position where it would be inserted */
1012  );
1013 
1014 /** Adds quadratic elements with same index and removes elements with coefficient 0.0.
1015  * Assumes that elements have been sorted before.
1016  */
1017 extern
1018 void SCIPquadelemSqueeze(
1019  SCIP_QUADELEM* quadelems, /**< array of quadratic elements */
1020  int nquadelems, /**< number of quadratic elements */
1021  int* nquadelemsnew /**< pointer to store new (reduced) number of quadratic elements */
1022  );
1023 
1024 /**@} */
1025 
1026 /**@name Expression graph node methods */
1027 /**@{ */
1028 
1029 /** captures node, i.e., increases number of uses */
1030 extern
1031 void SCIPexprgraphCaptureNode(
1032  SCIP_EXPRGRAPHNODE* node /**< expression graph node to capture */
1033  );
1034 
1035 /** returns whether a node is currently enabled */
1036 extern
1037 SCIP_Bool SCIPexprgraphIsNodeEnabled(
1038  SCIP_EXPRGRAPHNODE* node /**< expression graph node to enable */
1039  );
1040 
1041 /** gets number of children of a node in an expression graph */
1042 extern
1043 int SCIPexprgraphGetNodeNChildren(
1044  SCIP_EXPRGRAPHNODE* node /**< expression graph node */
1045  );
1046 
1047 /** gets children of a node in an expression graph */
1048 extern
1049 SCIP_EXPRGRAPHNODE** SCIPexprgraphGetNodeChildren(
1050  SCIP_EXPRGRAPHNODE* node /**< expression graph node */
1051  );
1052 
1053 /** gets number of parents of a node in an expression graph */
1054 extern
1055 int SCIPexprgraphGetNodeNParents(
1056  SCIP_EXPRGRAPHNODE* node /**< expression graph node */
1057  );
1058 
1059 /** gets parents of a node in an expression graph */
1060 extern
1061 SCIP_EXPRGRAPHNODE** SCIPexprgraphGetNodeParents(
1062  SCIP_EXPRGRAPHNODE* node /**< expression graph node */
1063  );
1064 
1065 /** gets depth of node in expression graph */
1066 extern
1067 int SCIPexprgraphGetNodeDepth(
1068  SCIP_EXPRGRAPHNODE* node /**< expression graph node */
1069  );
1070 
1071 /** gets position of node in expression graph at its depth level */
1072 extern
1073 int SCIPexprgraphGetNodePosition(
1074  SCIP_EXPRGRAPHNODE* node /**< expression graph node */
1075  );
1076 
1077 /** gets operator of a node in an expression graph */
1078 extern
1079 SCIP_EXPROP SCIPexprgraphGetNodeOperator(
1080  SCIP_EXPRGRAPHNODE* node /**< expression graph node */
1081  );
1082 
1083 /** gives index belonging to a SCIP_EXPR_VARIDX or SCIP_EXPR_PARAM operand */
1084 extern
1085 int SCIPexprgraphGetNodeOperatorIndex(
1086  SCIP_EXPRGRAPHNODE* node /**< expression graph node */
1087  );
1088 
1089 /** gives real belonging to a SCIP_EXPR_CONST operand */
1090 extern
1091 SCIP_Real SCIPexprgraphGetNodeOperatorReal(
1092  SCIP_EXPRGRAPHNODE* node /**< expression graph node */
1093  );
1094 
1095 /** gives variable belonging to a SCIP_EXPR_VARIDX expression */
1096 extern
1097 void* SCIPexprgraphGetNodeVar(
1098  SCIP_EXPRGRAPH* exprgraph, /**< expression graph */
1099  SCIP_EXPRGRAPHNODE* node /**< expression graph node */
1100  );
1101 
1102 /** gives exponent belonging to a SCIP_EXPR_REALPOWER expression */
1103 extern
1104 SCIP_Real SCIPexprgraphGetNodeRealPowerExponent(
1105  SCIP_EXPRGRAPHNODE* node /**< expression graph node */
1106  );
1107 
1108 /** gives exponent belonging to a SCIP_EXPR_INTPOWER expression */
1109 extern
1110 int SCIPexprgraphGetNodeIntPowerExponent(
1111  SCIP_EXPRGRAPHNODE* node /**< expression graph node */
1112  );
1113 
1114 /** gives exponent belonging to a SCIP_EXPR_SIGNPOWER expression */
1115 extern
1116 SCIP_Real SCIPexprgraphGetNodeSignPowerExponent(
1117  SCIP_EXPRGRAPHNODE* node /**< expression graph node */
1118  );
1119 
1120 /** gives linear coefficients belonging to a SCIP_EXPR_LINEAR expression */
1121 extern
1122 SCIP_Real* SCIPexprgraphGetNodeLinearCoefs(
1123  SCIP_EXPRGRAPHNODE* node /**< expression graph node */
1124  );
1125 
1126 /** gives constant belonging to a SCIP_EXPR_LINEAR expression */
1127 extern
1128 SCIP_Real SCIPexprgraphGetNodeLinearConstant(
1129  SCIP_EXPRGRAPHNODE* node /**< expression graph node */
1130  );
1131 
1132 /** gives constant belonging to a SCIP_EXPR_QUADRATIC expression */
1133 extern
1134 SCIP_Real SCIPexprgraphGetNodeQuadraticConstant(
1135  SCIP_EXPRGRAPHNODE* node /**< expression graph node */
1136  );
1137 
1138 /** gives linear coefficients belonging to a SCIP_EXPR_QUADRATIC expression, or NULL if all coefficients are 0.0 */
1139 extern
1140 SCIP_Real* SCIPexprgraphGetNodeQuadraticLinearCoefs(
1141  SCIP_EXPRGRAPHNODE* node /**< expression graph node */
1142  );
1143 
1144 /** gives quadratic elements belonging to a SCIP_EXPR_QUADRATIC expression */
1145 extern
1146 SCIP_QUADELEM* SCIPexprgraphGetNodeQuadraticQuadElements(
1147  SCIP_EXPRGRAPHNODE* node /**< expression graph node */
1148  );
1149 
1150 /** gives number of quadratic elements belonging to a SCIP_EXPR_QUADRATIC expression */
1151 extern
1152 int SCIPexprgraphGetNodeQuadraticNQuadElements(
1153  SCIP_EXPRGRAPHNODE* node /**< expression graph node */
1154  );
1155 
1156 /** gives the monomials belonging to a SCIP_EXPR_POLYNOMIAL expression */
1157 extern
1158 SCIP_EXPRDATA_MONOMIAL** SCIPexprgraphGetNodePolynomialMonomials(
1159  SCIP_EXPRGRAPHNODE* node /**< expression graph node */
1160  );
1161 
1162 /** gives the number of monomials belonging to a SCIP_EXPR_POLYNOMIAL expression */
1163 extern
1164 int SCIPexprgraphGetNodePolynomialNMonomials(
1165  SCIP_EXPRGRAPHNODE* node /**< expression graph node */
1166  );
1167 
1168 /** gives the constant belonging to a SCIP_EXPR_POLYNOMIAL expression */
1169 extern
1170 SCIP_Real SCIPexprgraphGetNodePolynomialConstant(
1171  SCIP_EXPRGRAPHNODE* node /**< expression graph node */
1172  );
1173 
1174 /** gives the curvature of a single monomial belonging to a SCIP_EXPR_POLYNOMIAL expression */
1175 extern
1176 SCIP_RETCODE SCIPexprgraphGetNodePolynomialMonomialCurvature(
1177  SCIP_EXPRGRAPHNODE* node, /**< expression graph node */
1178  int monomialidx, /**< index of monomial */
1179  SCIP_Real infinity, /**< value for infinity in interval arithmetics */
1180  SCIP_EXPRCURV* curv /**< buffer to store monomial curvature */
1181  );
1182 
1183 /** gives the user data belonging to a SCIP_EXPR_USER expression */
1184 extern
1185 SCIP_USEREXPRDATA* SCIPexprgraphGetNodeUserData(
1186  SCIP_EXPRGRAPHNODE* node
1187  );
1188 
1189 /** indicates whether a user expression has the estimator callback defined */
1190 extern
1191 SCIP_Bool SCIPexprgraphHasNodeUserEstimator(
1192  SCIP_EXPRGRAPHNODE* node
1193  );
1194 
1195 /** gets bounds of a node in an expression graph */
1196 extern
1197 SCIP_INTERVAL SCIPexprgraphGetNodeBounds(
1198  SCIP_EXPRGRAPHNODE* node /**< expression graph node */
1199  );
1200 
1201 /** gets value of expression associated to node from last evaluation call */
1202 extern
1203 SCIP_Real SCIPexprgraphGetNodeVal(
1204  SCIP_EXPRGRAPHNODE* node /**< expression graph node */
1205  );
1206 
1207 /** gets curvature of expression associated to node from last curvature check call */
1208 extern
1209 SCIP_EXPRCURV SCIPexprgraphGetNodeCurvature(
1210  SCIP_EXPRGRAPHNODE* node /**< expression graph node */
1211  );
1212 
1213 #ifdef NDEBUG
1214 
1215 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
1216  * speed up the algorithms.
1217  */
1218 
1219 #define SCIPexprgraphCaptureNode(node) do { ++(node)->nuses; } while( FALSE )
1220 #define SCIPexprgraphIsNodeEnabled(node) (node)->enabled
1221 #define SCIPexprgraphGetNodeNChildren(node) (node)->nchildren
1222 #define SCIPexprgraphGetNodeChildren(node) (node)->children
1223 #define SCIPexprgraphGetNodeNParents(node) (node)->nparents
1224 #define SCIPexprgraphGetNodeParents(node) (node)->parents
1225 #define SCIPexprgraphGetNodeDepth(node) (node)->depth
1226 #define SCIPexprgraphGetNodePosition(node) (node)->pos
1227 #define SCIPexprgraphGetNodeOperator(node) (node)->op
1228 #define SCIPexprgraphGetNodeOperatorIndex(node) (node)->data.intval
1229 #define SCIPexprgraphGetNodeOperatorReal(node) (node)->data.dbl
1230 #define SCIPexprgraphGetNodeVar(exprgraph, node) (exprgraph)->vars[(node)->data.intval]
1231 #define SCIPexprgraphGetNodeRealPowerExponent(node) (node)->data.dbl
1232 #define SCIPexprgraphGetNodeIntPowerExponent(node) (node)->data.intval
1233 #define SCIPexprgraphGetNodeSignPowerExponent(node) (node)->data.dbl
1234 #define SCIPexprgraphGetNodeLinearCoefs(node) ((SCIP_Real*)(node)->data.data)
1235 #define SCIPexprgraphGetNodeLinearConstant(node) (((SCIP_Real*)(node)->data.data)[(node)->nchildren])
1236 #define SCIPexprgraphGetNodeQuadraticConstant(node) ((SCIP_EXPRDATA_QUADRATIC*)(node)->data.data)->constant
1237 #define SCIPexprgraphGetNodeQuadraticLinearCoefs(node) ((SCIP_EXPRDATA_QUADRATIC*)(node)->data.data)->lincoefs
1238 #define SCIPexprgraphGetNodeQuadraticQuadElements(node) ((SCIP_EXPRDATA_QUADRATIC*)(node)->data.data)->quadelems
1239 #define SCIPexprgraphGetNodeQuadraticNQuadElements(node) ((SCIP_EXPRDATA_QUADRATIC*)(node)->data.data)->nquadelems
1240 #define SCIPexprgraphGetNodePolynomialMonomials(node) ((SCIP_EXPRDATA_POLYNOMIAL*)(node)->data.data)->monomials
1241 #define SCIPexprgraphGetNodePolynomialNMonomials(node) ((SCIP_EXPRDATA_POLYNOMIAL*)(node)->data.data)->nmonomials
1242 #define SCIPexprgraphGetNodePolynomialConstant(node) ((SCIP_EXPRDATA_POLYNOMIAL*)(node)->data.data)->constant
1243 #define SCIPexprgraphGetNodeUserData(node) ((SCIP_EXPRDATA_USER*)(node)->data.data)->userdata
1244 #define SCIPexprgraphHasNodeUserEstimator(node) (((SCIP_EXPRDATA_USER*)node->data.data)->estimate != NULL)
1245 #define SCIPexprgraphGetNodeBounds(node) (node)->bounds
1246 #define SCIPexprgraphGetNodeVal(node) (node)->value
1247 #define SCIPexprgraphGetNodeCurvature(node) (node)->curv
1248 
1249 #endif
1250 
1251 /** creates an expression graph node */
1252 extern
1253 SCIP_RETCODE SCIPexprgraphCreateNode(
1254  BMS_BLKMEM* blkmem, /**< block memory */
1255  SCIP_EXPRGRAPHNODE** node, /**< buffer to store expression graph node */
1256  SCIP_EXPROP op, /**< operator type of expression */
1257  ...
1258  );
1259 
1260 /** creates an expression graph node for a linear expression */
1261 extern
1262 SCIP_RETCODE SCIPexprgraphCreateNodeLinear(
1263  BMS_BLKMEM* blkmem, /**< block memory */
1264  SCIP_EXPRGRAPHNODE** node, /**< buffer to store expression graph node */
1265  int ncoefs, /**< number of coefficients */
1266  SCIP_Real* coefs, /**< coefficients of linear expression */
1267  SCIP_Real constant /**< constant of linear expression */
1268  );
1269 
1270 /** creates an expression graph node for a quadratic expression */
1271 extern
1272 SCIP_RETCODE SCIPexprgraphCreateNodeQuadratic(
1273  BMS_BLKMEM* blkmem, /**< block memory */
1274  SCIP_EXPRGRAPHNODE** node, /**< buffer to store expression graph node */
1275  int nchildren, /**< number of children */
1276  SCIP_Real* lincoefs, /**< linear coefficients for children, or NULL */
1277  int nquadelems, /**< number of quadratic elements */
1278  SCIP_QUADELEM* quadelems, /**< quadratic elements, or NULL if nquadelems == 0 */
1279  SCIP_Real constant /**< constant */
1280  );
1281 
1282 /** creates an expression graph node for a polynomial expression */
1283 extern
1284 SCIP_RETCODE SCIPexprgraphCreateNodePolynomial(
1285  BMS_BLKMEM* blkmem, /**< block memory */
1286  SCIP_EXPRGRAPHNODE** node, /**< buffer to store expression graph node */
1287  int nmonomials, /**< number of monomials */
1288  SCIP_EXPRDATA_MONOMIAL** monomials, /**< monomials */
1289  SCIP_Real constant, /**< constant of polynomial */
1290  SCIP_Bool copymonomials /**< whether to copy monomials or to assume ownership */
1291  );
1292 
1293 /** adds monomials to an expression graph node that is a polynomial expression */
1294 extern
1295 SCIP_RETCODE SCIPexprgraphNodePolynomialAddMonomials(
1296  BMS_BLKMEM* blkmem, /**< block memory */
1297  SCIP_EXPRGRAPHNODE* node, /**< store expression graph node with polynomial operator */
1298  int nmonomials, /**< number of monomials */
1299  SCIP_EXPRDATA_MONOMIAL** monomials, /**< monomials */
1300  SCIP_Bool copymonomials /**< whether to copy monomials or to assume ownership */
1301  );
1302 
1303 /** creates an expression graph node for a user expression */
1304 extern
1305 SCIP_RETCODE SCIPexprgraphCreateNodeUser(
1306  BMS_BLKMEM* blkmem, /**< block memory */
1307  SCIP_EXPRGRAPHNODE** node, /**< buffer to store expression graph node */
1308  SCIP_USEREXPRDATA* data, /**< user data for expression, node assumes ownership */
1309  SCIP_EXPRINTCAPABILITY evalcapability, /**< evaluation capability */
1310  SCIP_DECL_USEREXPREVAL ((*eval)), /**< evaluation function */
1311  SCIP_DECL_USEREXPRINTEVAL ((*inteval)), /**< interval evaluation function */
1312  SCIP_DECL_USEREXPRCURV ((*curv)), /**< curvature check function */
1313  SCIP_DECL_USEREXPRPROP ((*prop)), /**< interval propagation function */
1314  SCIP_DECL_USEREXPRESTIMATE ((*estimate)), /**< estimation function, or NULL if convex, concave, or not implemented */
1315  SCIP_DECL_USEREXPRCOPYDATA ((*copydata)), /**< expression data copy function, or NULL if nothing to copy */
1316  SCIP_DECL_USEREXPRFREEDATA ((*freedata)), /**< expression data free function, or NULL if nothing to free */
1317  SCIP_DECL_USEREXPRPRINT ((*print)) /**< expression print function, or NULL for default string "user" */
1318  );
1319 
1320 /** given a node of an expression graph, splitup a linear part which variables are not used somewhere else in the same expression
1321  * E.g., if the expression is 1 + x + y + y^2, one gets 1 + x and the node remains at y + y^2.
1322  * If the node is a linear expression, it may be freed.
1323  * If it is not linear, the node may change, i.e., the remaining nonlinear part may be stored in a new node.
1324  * It is assumed that the user had captured the node.
1325  * It is assumed that the expression graph has been simplified before.
1326  */
1327 extern
1328 SCIP_RETCODE SCIPexprgraphNodeSplitOffLinear(
1329  SCIP_EXPRGRAPH* exprgraph, /**< expression graph */
1330  SCIP_EXPRGRAPHNODE** node, /**< expression graph node where to splitup linear part */
1331  int linvarssize, /**< length of linvars and lincoefs arrays */
1332  int* nlinvars, /**< buffer to store length of linear term that have been splitup */
1333  void** linvars, /**< buffer to store variables of linear part */
1334  SCIP_Real* lincoefs, /**< buffer to store coefficients of linear part */
1335  SCIP_Real* constant /**< buffer to store constant part */
1336  );
1337 
1338 /** moves parents from a one node to another node
1339  * in other words, replaces the child srcnode by targetnode in all parents of srcnode
1340  * srcnode may be freed, if not captured
1341  * it is assumes that targetnode represents the same expression as srcnode
1342  */
1343 extern
1344 SCIP_RETCODE SCIPexprgraphMoveNodeParents(
1345  SCIP_EXPRGRAPH* exprgraph, /**< expression graph */
1346  SCIP_EXPRGRAPHNODE** srcnode, /**< node which parents to move */
1347  SCIP_EXPRGRAPHNODE* targetnode /**< node where to move parents to */
1348  );
1349 
1350 /** releases node, i.e., decreases number of uses
1351  * node is freed if no parents and no other uses
1352  * children are recursively released if they have no other parents
1353  * nodes that are removed are also freed
1354  * if node correspond to a variable, then the variable is removed from the expression graph
1355  * similar for constants
1356  */
1357 extern
1358 SCIP_RETCODE SCIPexprgraphReleaseNode(
1359  SCIP_EXPRGRAPH* exprgraph, /**< expression graph */
1360  SCIP_EXPRGRAPHNODE** node /**< expression graph node to release */
1361  );
1362 
1363 /** frees a node of an expression graph */
1364 extern
1365 void SCIPexprgraphFreeNode(
1366  BMS_BLKMEM* blkmem, /**< block memory */
1367  SCIP_EXPRGRAPHNODE** node /**< pointer to expression graph node that should be freed */
1368  );
1369 
1370 /** enables a node and recursively all its children in an expression graph */
1371 extern
1372 void SCIPexprgraphEnableNode(
1373  SCIP_EXPRGRAPH* exprgraph, /**< expression graph */
1374  SCIP_EXPRGRAPHNODE* node /**< expression graph node to enable */
1375  );
1376 
1377 /** disables a node and recursively all children which have no enabled parents in an expression graph */
1378 extern
1379 void SCIPexprgraphDisableNode(
1380  SCIP_EXPRGRAPH* exprgraph, /**< expression graph */
1381  SCIP_EXPRGRAPHNODE* node /**< expression graph node to enable */
1382  );
1383 
1384 /** returns whether the node has siblings in the expression graph */
1385 extern
1386 SCIP_Bool SCIPexprgraphHasNodeSibling(
1387  SCIP_EXPRGRAPHNODE* node /**< expression graph node */
1388  );
1389 
1390 /** returns whether all children of an expression graph node are variable nodes
1391  * gives TRUE for nodes without children
1392  */
1393 extern
1394 SCIP_Bool SCIPexprgraphAreAllNodeChildrenVars(
1395  SCIP_EXPRGRAPHNODE* node /**< expression graph node */
1396  );
1397 
1398 /** returns whether the node has an ancestor which has a nonlinear expression operand */
1399 extern
1400 SCIP_Bool SCIPexprgraphHasNodeNonlinearAncestor(
1401  SCIP_EXPRGRAPHNODE* node /**< expression graph node */
1402  );
1403 
1404 /** prints an expression graph node */
1405 extern
1406 void SCIPexprgraphPrintNode(
1407  SCIP_EXPRGRAPHNODE* node, /**< expression graph node */
1408  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1409  FILE* file /**< file to print to, or NULL for stdout */
1410  );
1411 
1412 /** tightens the bounds in a node of the graph
1413  * preparation for reverse propagation
1414  * sets bound status to SCIP_EXPRBOUNDSTATUS_TIGHTENEDBYPARENTRECENT if tightening is strong enough and not cutoff
1415  */
1416 extern
1417 void SCIPexprgraphTightenNodeBounds(
1418  SCIP_EXPRGRAPH* exprgraph, /**< expression graph */
1419  SCIP_EXPRGRAPHNODE* node, /**< node in expression graph with no parents */
1420  SCIP_INTERVAL nodebounds, /**< new bounds for node */
1421  SCIP_Real minstrength, /**< minimal required relative bound strengthening in a node to trigger a propagation into children nodes (set to negative value if propagation should always be triggered) */
1422  SCIP_Real infinity, /**< value for infinity in interval arithmetics */
1423  SCIP_Bool* cutoff /**< buffer to store whether a node's bounds were propagated to an empty interval */
1424  );
1425 
1426 /** ensures that bounds and curvature information in a node is uptodate
1427  * assumes that bounds and curvature in children are uptodate
1428  */
1429 extern
1430 SCIP_RETCODE SCIPexprgraphUpdateNodeBoundsCurvature(
1431  SCIP_EXPRGRAPHNODE* node, /**< expression graph node */
1432  SCIP_Real infinity, /**< value for infinity in interval arithmetics */
1433  SCIP_Real minstrength, /**< minimal required relative bound strengthening to trigger a bound recalculation in parent nodes */
1434  SCIP_Bool clearreverseprop /**< whether to reset bound tightenings from reverse propagation */
1435  );
1436 
1437 /**@} */
1438 
1439 /**@name Expression graph methods */
1440 /**@{ */
1441 
1442 /** get current maximal depth of expression graph */
1443 extern
1444 int SCIPexprgraphGetDepth(
1445  SCIP_EXPRGRAPH* exprgraph /**< expression graph */
1446  );
1447 
1448 /** gets array with number of nodes at each depth of expression graph */
1449 extern
1450 int* SCIPexprgraphGetNNodes(
1451  SCIP_EXPRGRAPH* exprgraph /**< expression graph */
1452  );
1453 
1454 /** gets nodes of expression graph, one array per depth */
1455 extern
1456 SCIP_EXPRGRAPHNODE*** SCIPexprgraphGetNodes(
1457  SCIP_EXPRGRAPH* exprgraph /**< expression graph */
1458  );
1459 
1460 /** gets number of variables in expression graph */
1461 extern
1462 int SCIPexprgraphGetNVars(
1463  SCIP_EXPRGRAPH* exprgraph /**< pointer to expression graph that should be freed */
1464  );
1465 
1466 /** gets array of variables in expression graph */
1467 extern
1468 void** SCIPexprgraphGetVars(
1469  SCIP_EXPRGRAPH* exprgraph /**< pointer to expression graph that should be freed */
1470  );
1471 
1472 /** gets array of expression graph nodes corresponding to variables */
1473 extern
1474 SCIP_EXPRGRAPHNODE** SCIPexprgraphGetVarNodes(
1475  SCIP_EXPRGRAPH* exprgraph /**< pointer to expression graph that should be freed */
1476  );
1477 
1478 /** sets value for a single variable given as expression graph node */
1479 extern
1480 void SCIPexprgraphSetVarNodeValue(
1481  SCIP_EXPRGRAPHNODE* varnode, /**< expression graph node corresponding to variable */
1482  SCIP_Real value /**< new value for variable */
1483  );
1484 
1485 /** sets bounds for variables */
1486 extern
1487 void SCIPexprgraphSetVarsBounds(
1488  SCIP_EXPRGRAPH* exprgraph, /**< expression graph */
1489  SCIP_INTERVAL* varbounds /**< new bounds for variables */
1490  );
1491 
1492 /** sets bounds for a single variable */
1493 extern
1494 void SCIPexprgraphSetVarBounds(
1495  SCIP_EXPRGRAPH* exprgraph, /**< expression graph */
1496  void* var, /**< variable */
1497  SCIP_INTERVAL varbounds /**< new bounds of variable */
1498  );
1499 
1500 /** sets bounds for a single variable given as expression graph node */
1501 extern
1502 void SCIPexprgraphSetVarNodeBounds(
1503  SCIP_EXPRGRAPH* exprgraph, /**< expression graph */
1504  SCIP_EXPRGRAPHNODE* varnode, /**< expression graph node corresponding to variable */
1505  SCIP_INTERVAL varbounds /**< new bounds of variable */
1506  );
1507 
1508 /** sets lower bound for a single variable given as expression graph node */
1509 extern
1510 void SCIPexprgraphSetVarNodeLb(
1511  SCIP_EXPRGRAPH* exprgraph, /**< expression graph */
1512  SCIP_EXPRGRAPHNODE* varnode, /**< expression graph node corresponding to variable */
1513  SCIP_Real lb /**< new lower bound for variable */
1514  );
1515 
1516 /** sets upper bound for a single variable given as expression graph node */
1517 extern
1518 void SCIPexprgraphSetVarNodeUb(
1519  SCIP_EXPRGRAPH* exprgraph, /**< expression graph */
1520  SCIP_EXPRGRAPHNODE* varnode, /**< expression graph node corresponding to variable */
1521  SCIP_Real ub /**< new upper bound for variable */
1522  );
1523 
1524 /** gets bounds that are stored for all variables */
1525 extern
1526 SCIP_INTERVAL* SCIPexprgraphGetVarsBounds(
1527  SCIP_EXPRGRAPH* exprgraph /**< expression graph */
1528  );
1529 
1530 #ifdef NDEBUG
1531 
1532 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
1533  * speed up the algorithms.
1534  */
1535 
1536 #define SCIPexprgraphGetDepth(exprgraph) (exprgraph)->depth
1537 #define SCIPexprgraphGetNNodes(exprgraph) (exprgraph)->nnodes
1538 #define SCIPexprgraphGetNodes(exprgraph) (exprgraph)->nodes
1539 #define SCIPexprgraphGetNVars(exprgraph) (exprgraph)->nvars
1540 #define SCIPexprgraphGetVars(exprgraph) (exprgraph)->vars
1541 #define SCIPexprgraphGetVarNodes(exprgraph) (exprgraph)->varnodes
1542 #define SCIPexprgraphSetVarNodeValue(varnode, newvalue) do { (varnode)->value = newvalue; } while (FALSE)
1543 #define SCIPexprgraphSetVarsBounds(exprgraph, newvarbounds) BMScopyMemoryArray((exprgraph)->varbounds, newvarbounds, (exprgraph)->nvars)
1544 #define SCIPexprgraphSetVarBounds(exprgraph, var, newvarbounds) do { (exprgraph)->varbounds[(int)(size_t)SCIPhashmapGetImage((exprgraph)->varidxs, var)] = newvarbounds; } while (FALSE)
1545 #define SCIPexprgraphSetVarNodeBounds(exprgraph, varnode, newvarbounds) do { (exprgraph)->varbounds[(varnode)->data.intval] = newvarbounds; } while (FALSE)
1546 #define SCIPexprgraphSetVarNodeLb(exprgraph, varnode, lb) do { (exprgraph)->varbounds[(varnode)->data.intval].inf = lb; } while (FALSE)
1547 #define SCIPexprgraphSetVarNodeUb(exprgraph, varnode, ub) do { (exprgraph)->varbounds[(varnode)->data.intval].sup = ub; } while (FALSE)
1548 #define SCIPexprgraphGetVarsBounds(exprgraph) (exprgraph)->varbounds
1549 
1550 #endif
1551 
1552 /** creates an empty expression graph */
1553 extern
1554 SCIP_RETCODE SCIPexprgraphCreate(
1555  BMS_BLKMEM* blkmem, /**< block memory */
1556  SCIP_EXPRGRAPH** exprgraph, /**< buffer to store pointer to expression graph */
1557  int varssizeinit, /**< minimal initial size for variables array, or -1 to choose automatically */
1558  int depthinit, /**< minimal initial depth of expression graph, or -1 to choose automatically */
1559  SCIP_DECL_EXPRGRAPHVARADDED((*exprgraphvaradded)), /**< callback method to invoke when a variable has been added to the expression graph, or NULL if not needed */
1560  SCIP_DECL_EXPRGRAPHVARREMOVE((*exprgraphvarremove)), /**< callback method to invoke when a variable will be removed from the expression graph, or NULL if not needed */
1561  SCIP_DECL_EXPRGRAPHVARCHGIDX((*exprgraphvarchgidx)), /**< callback method to invoke when a variable changes its index in the expression graph, or NULL if not needed */
1562  void* userdata /**< user data to pass to callback functions */
1563  );
1564 
1565 /** frees an expression graph */
1566 extern
1567 SCIP_RETCODE SCIPexprgraphFree(
1568  SCIP_EXPRGRAPH** exprgraph /**< pointer to expression graph that should be freed */
1569  );
1570 
1571 /** adds an expression graph node to an expression graph
1572  * expression graph assumes ownership of node
1573  * children are notified about new parent
1574  * depth will be chosen to be the maximum of mindepth and the depth of all children plus one
1575  */
1576 extern
1577 SCIP_RETCODE SCIPexprgraphAddNode(
1578  SCIP_EXPRGRAPH* exprgraph, /**< expression graph */
1579  SCIP_EXPRGRAPHNODE* node, /**< expression graph node to add */
1580  int mindepth, /**< minimal depth in expression graph where to add node, e.g., 0 or smaller to choose automatically */
1581  int nchildren, /**< number of children */
1582  SCIP_EXPRGRAPHNODE** children /**< children nodes, or NULL if no children */
1583  );
1584 
1585 /** adds variables to an expression graph, if not existing yet
1586  * also already existing nodes are enabled
1587  */
1588 extern
1589 SCIP_RETCODE SCIPexprgraphAddVars(
1590  SCIP_EXPRGRAPH* exprgraph, /**< expression graph */
1591  int nvars, /**< number of variables to add */
1592  void** vars, /**< variables to add */
1593  SCIP_EXPRGRAPHNODE** varnodes /**< array to store nodes corresponding to variables, or NULL if not of interest */
1594  );
1595 
1596 /** adds a constant to an expression graph, if not existing yet
1597  * also already existing nodes are enabled
1598  */
1599 SCIP_RETCODE SCIPexprgraphAddConst(
1600  SCIP_EXPRGRAPH* exprgraph, /**< expression graph */
1601  SCIP_Real constant, /**< constant to add */
1602  SCIP_EXPRGRAPHNODE** constnode /**< buffer to store pointer to expression graph node corresponding to constant */
1603  );
1604 
1605 /** adds sum of expression trees into expression graph
1606  * node will also be captured
1607  */
1608 extern
1609 SCIP_RETCODE SCIPexprgraphAddExprtreeSum(
1610  SCIP_EXPRGRAPH* exprgraph, /**< expression graph */
1611  int nexprtrees, /**< number of expression trees to add */
1612  SCIP_EXPRTREE** exprtrees, /**< expression trees that should be added */
1613  SCIP_Real* coefs, /**< coefficients of expression trees, or NULL if all 1.0 */
1614  SCIP_EXPRGRAPHNODE** rootnode, /**< buffer to store expression graph node corresponding to root of expression tree */
1615  SCIP_Bool* rootnodeisnew /**< buffer to indicate whether the node in *rootnode has been newly created for this expression tree (otherwise, expression tree was already in graph) */
1616  );
1617 
1618 /** replaces variable in expression graph by a linear sum of variables
1619  * variables will be added if not in the graph yet
1620  */
1621 extern
1622 SCIP_RETCODE SCIPexprgraphReplaceVarByLinearSum(
1623  SCIP_EXPRGRAPH* exprgraph, /**< expression graph */
1624  void* var, /**< variable to replace */
1625  int ncoefs, /**< number of coefficients in linear term */
1626  SCIP_Real* coefs, /**< coefficients in linear term, or NULL if ncoefs == 0 */
1627  void** vars, /**< variables in linear term */
1628  SCIP_Real constant /**< constant offset */
1629  );
1630 
1631 /** finds expression graph node corresponding to a variable */
1632 extern
1633 SCIP_Bool SCIPexprgraphFindVarNode(
1634  SCIP_EXPRGRAPH* exprgraph, /**< expression graph */
1635  void* var, /**< variable to search for */
1636  SCIP_EXPRGRAPHNODE** varnode /**< buffer to store node corresponding to variable, if found, or NULL if not found */
1637  );
1638 
1639 /** finds expression graph node corresponding to a constant */
1640 extern
1641 SCIP_Bool SCIPexprgraphFindConstNode(
1642  SCIP_EXPRGRAPH* exprgraph, /**< expression graph */
1643  SCIP_Real constant, /**< constant to search for */
1644  SCIP_EXPRGRAPHNODE** constnode /**< buffer to store node corresponding to constant, if found, or NULL if not found */
1645  );
1646 
1647 /** prints an expression graph in dot format */
1648 extern
1649 SCIP_RETCODE SCIPexprgraphPrintDot(
1650  SCIP_EXPRGRAPH* exprgraph, /**< expression graph */
1651  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1652  FILE* file, /**< file to print to, or NULL for stdout */
1653  const char** varnames /**< variable names, or NULL for generic names */
1654  );
1655 
1656 /** evaluates nodes of expression graph for given values of variables */
1657 extern
1658 SCIP_RETCODE SCIPexprgraphEval(
1659  SCIP_EXPRGRAPH* exprgraph, /**< expression graph */
1660  SCIP_Real* varvals /**< values for variables */
1661  );
1662 
1663 /** propagates bound changes in variables forward through the expression graph */
1664 extern
1665 SCIP_RETCODE SCIPexprgraphPropagateVarBounds(
1666  SCIP_EXPRGRAPH* exprgraph, /**< expression graph */
1667  SCIP_Real infinity, /**< value for infinity in interval arithmetics */
1668  SCIP_Bool clearreverseprop, /**< whether to reset bound tightenings from reverse propagation */
1669  SCIP_Bool* domainerror /**< buffer to store whether a node with empty bounds has been found, propagation is interrupted in this case */
1670  );
1671 
1672 /** propagates bound changes in nodes backward through the graph
1673  * new bounds are not stored in varbounds, but only in nodes corresponding to variables
1674  * NOTE: it is assumed that SCIPexprgraphPropagateVarBounds was called before if variable bounds were relaxed
1675  */
1676 extern
1677 void SCIPexprgraphPropagateNodeBounds(
1678  SCIP_EXPRGRAPH* exprgraph, /**< expression graph */
1679  SCIP_Real infinity, /**< value for infinity in interval arithmetics */
1680  SCIP_Real minstrength, /**< minimal required relative bound strengthening in a node to trigger a propagation into children nodes */
1681  SCIP_Bool* cutoff /**< buffer to store whether a node's bounds were propagated to an empty interval */
1682  );
1683 
1684 /** updates curvature information in expression graph nodes w.r.t. currently stored variable bounds
1685  * implies update of bounds in expression graph
1686  */
1687 extern
1688 SCIP_RETCODE SCIPexprgraphCheckCurvature(
1689  SCIP_EXPRGRAPH* exprgraph, /**< expression graph */
1690  SCIP_Real infinity, /**< value for infinity in interval arithmetics */
1691  SCIP_Bool clearreverseprop /**< whether to reset bound tightenings from reverse propagation */
1692  );
1693 
1694 /** aims at simplifying an expression graph
1695  * a domain error can occur when variables were fixed to values for which a parent expression is not defined (e.g., 0^(-1) or log(-1))
1696  */
1697 extern
1698 SCIP_RETCODE SCIPexprgraphSimplify(
1699  SCIP_EXPRGRAPH* exprgraph, /**< expression graph */
1700  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1701  SCIP_Real eps, /**< threshold, under which positive values are treat as 0 */
1702  int maxexpansionexponent,/**< maximal exponent for which we still expand non-monomial polynomials */
1703  SCIP_Bool* havechange, /**< buffer to indicate whether the graph has been modified */
1704  SCIP_Bool* domainerror /**< buffer to indicate whether a domain error has been encountered, i.e., some expressions turned into NaN */
1705  );
1706 
1707 /** creates an expression tree from a given node in an expression graph */
1708 extern
1709 SCIP_RETCODE SCIPexprgraphGetTree(
1710  SCIP_EXPRGRAPH* exprgraph, /**< expression graph */
1711  SCIP_EXPRGRAPHNODE* rootnode, /**< expression graph node that should represent root of expression tree */
1712  SCIP_EXPRTREE** exprtree /**< buffer to store pointer to created expression tree */
1713  );
1714 
1715 /** creates a sum of expression trees with pairwise disjoint variables from a given node in an expression graph
1716  * Giving SCIPexprgraphGetNodeNChildren() for exprtreesize is always sufficient.
1717  */
1718 extern
1719 SCIP_RETCODE SCIPexprgraphGetSeparableTrees(
1720  SCIP_EXPRGRAPH* exprgraph, /**< expression graph */
1721  SCIP_EXPRGRAPHNODE* node, /**< expression graph node which represents expression to get */
1722  int exprtreessize, /**< length of exprtrees and exprtreecoefs arrays, need to be at least one */
1723  int* nexprtrees, /**< buffer to store number of expression trees */
1724  SCIP_EXPRTREE** exprtrees, /**< array where to store expression trees */
1725  SCIP_Real* exprtreecoefs /**< array where to store coefficients of expression trees */
1726  );
1727 
1728 /** returns how often expression graph variables are used in a subtree of the expression graph */
1729 extern
1730 void SCIPexprgraphGetSubtreeVarsUsage(
1731  SCIP_EXPRGRAPH* exprgraph, /**< expression graph */
1732  SCIP_EXPRGRAPHNODE* node, /**< root node of expression graph subtree */
1733  int* varsusage /**< array where to count usage of variables, length must be at least the number of variables in the graph */
1734  );
1735 
1736 /** gives the number of summands which the expression of an expression graph node consists of */
1737 extern
1738 int SCIPexprgraphGetSumTreesNSummands(
1739  SCIP_EXPRGRAPHNODE* node /**< expression graph node */
1740  );
1741 
1742 /** creates a sum of expression trees, possibly sharing variables, from a given node in an expression graph */
1743 extern
1744 SCIP_RETCODE SCIPexprgraphGetSumTrees(
1745  SCIP_EXPRGRAPH* exprgraph, /**< expression graph */
1746  SCIP_EXPRGRAPHNODE* node, /**< expression graph node which represents expression to get */
1747  int exprtreessize, /**< length of exprtrees and exptreecoefs arrays, should be at least SCIPexprgraphGetSumTreesNSummands() */
1748  int* nexprtrees, /**< buffer to store number of expression trees */
1749  SCIP_EXPRTREE** exprtrees, /**< array where to store expression trees */
1750  SCIP_Real* exprtreecoefs /**< array where to store coefficients of expression trees */
1751  );
1752 
1753 /**@} */
1754 
1755 #ifdef __cplusplus
1756 }
1757 #endif
1758 
1759 #endif /* __NLPI_PUB_EXPR_H__ */
SCIPexprAdd
SCIP_RETCODE SCIPexprAdd(BMS_BLKMEM *blkmem, SCIP_EXPR **expr, SCIP_Real coef1, SCIP_EXPR *term1, SCIP_Real coef2, SCIP_EXPR *term2, SCIP_Real constant)
Definition: expr.c:6246
SCIPexprcurvNegate
SCIP_EXPRCURV SCIPexprcurvNegate(SCIP_EXPRCURV curvature)
Definition: expr.c:214
SCIPexprgraphGetNodeIntPowerExponent
int SCIPexprgraphGetNodeIntPowerExponent(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:13085
SCIPexprgraphGetVars
void ** SCIPexprgraphGetVars(SCIP_EXPRGRAPH *exprgraph)
Definition: expr.c:14953
SCIPexprMultiplyPolynomialByPolynomial
SCIP_RETCODE SCIPexprMultiplyPolynomialByPolynomial(BMS_BLKMEM *blkmem, SCIP_EXPR *expr, SCIP_EXPR *factor, int *childmap)
Definition: expr.c:6739
SCIPexprgraphDisableNode
void SCIPexprgraphDisableNode(SCIP_EXPRGRAPH *exprgraph, SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:14574
SCIPexprgraphAddConst
SCIP_RETCODE SCIPexprgraphAddConst(SCIP_EXPRGRAPH *exprgraph, SCIP_Real constant, SCIP_EXPRGRAPHNODE **constnode)
Definition: expr.c:15330
SCIPexprgraphGetNodePolynomialMonomialCurvature
SCIP_RETCODE SCIPexprgraphGetNodePolynomialMonomialCurvature(SCIP_EXPRGRAPHNODE *node, int monomialidx, SCIP_Real infinity, SCIP_EXPRCURV *curv)
Definition: expr.c:13217
eval
static SCIP_RETCODE eval(SCIP_EXPR *expr, const vector< Type > &x, SCIP_Real *param, Type &val)
Definition: exprinterpret_cppad.cpp:1766
SCIP_Interval
Definition: intervalarith.h:37
SCIPexprtreeGetVarsUsage
void SCIPexprtreeGetVarsUsage(SCIP_EXPRTREE *tree, int *varsusage)
Definition: expr.c:8907
SCIPquadelemSqueeze
void SCIPquadelemSqueeze(SCIP_QUADELEM *quadelems, int nquadelems, int *nquadelemsnew)
Definition: expr.c:9288
SCIPexprtreeEval
SCIP_RETCODE SCIPexprtreeEval(SCIP_EXPRTREE *tree, SCIP_Real *varvals, SCIP_Real *val)
Definition: expr.c:8723
SCIPexprgraphGetNodeNParents
int SCIPexprgraphGetNodeNParents(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:12987
SCIP_NlpiOracle::nvars
int nvars
Definition: nlpioracle.c:64
SCIPexprCreateQuadratic
SCIP_RETCODE SCIPexprCreateQuadratic(BMS_BLKMEM *blkmem, SCIP_EXPR **expr, int nchildren, SCIP_EXPR **children, SCIP_Real constant, SCIP_Real *lincoefs, int nquadelems, SCIP_QUADELEM *quadelems)
Definition: expr.c:6584
SCIPexprgraphGetNodeQuadraticQuadElements
SCIP_QUADELEM * SCIPexprgraphGetNodeQuadraticQuadElements(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:13154
SCIPexprGetNChildren
int SCIPexprGetNChildren(SCIP_EXPR *expr)
Definition: expr.c:5703
SCIPexprtreeSetInterpreterData
void SCIPexprtreeSetInterpreterData(SCIP_EXPRTREE *tree, SCIP_EXPRINTDATA *interpreterdata)
Definition: expr.c:8667
SCIPexprFreeMonomial
void SCIPexprFreeMonomial(BMS_BLKMEM *blkmem, SCIP_EXPRDATA_MONOMIAL **monomial)
Definition: expr.c:7092
SCIPexprGetQuadElements
SCIP_QUADELEM * SCIPexprGetQuadElements(SCIP_EXPR *expr)
Definition: expr.c:5815
infinity
#define infinity
Definition: gastrans.c:71
SCIP_USEREXPRDATA
struct SCIP_UserExprData SCIP_USEREXPRDATA
Definition: type_expr.h:221
SCIPexprGetUserEvalCapability
SCIP_EXPRINTCAPABILITY SCIPexprGetUserEvalCapability(SCIP_EXPR *expr)
Definition: expr.c:5962
SCIPexprgraphGetNodePolynomialNMonomials
int SCIPexprgraphGetNodePolynomialNMonomials(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:13190
SCIPexprGetMonomialCoef
SCIP_Real SCIPexprGetMonomialCoef(SCIP_EXPRDATA_MONOMIAL *monomial)
Definition: expr.c:5900
SCIPexprtreePrint
void SCIPexprtreePrint(SCIP_EXPRTREE *tree, SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char **varnames, const char **paramnames)
Definition: expr.c:8756
SCIP_DECL_USEREXPREVAL
#define SCIP_DECL_USEREXPREVAL(x)
Definition: type_expr.h:248
SCIP_DECL_USEREXPRPRINT
#define SCIP_DECL_USEREXPRPRINT(x)
Definition: type_expr.h:310
SCIPexprMergeMonomialFactors
void SCIPexprMergeMonomialFactors(SCIP_EXPRDATA_MONOMIAL *monomial, SCIP_Real eps)
Definition: expr.c:6956
SCIPexprgraphGetNodeLinearConstant
SCIP_Real SCIPexprgraphGetNodeLinearConstant(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:13118
SCIPexprgraphSetVarsBounds
void SCIPexprgraphSetVarsBounds(SCIP_EXPRGRAPH *exprgraph, SCIP_INTERVAL *varbounds)
Definition: expr.c:14985
type_exprinterpret.h
type definitions for expression interpreter
SCIPexprgraphNodeSplitOffLinear
SCIP_RETCODE SCIPexprgraphNodeSplitOffLinear(SCIP_EXPRGRAPH *exprgraph, SCIP_EXPRGRAPHNODE **node, int linvarssize, int *nlinvars, void **linvars, SCIP_Real *lincoefs, SCIP_Real *constant)
Definition: expr.c:13584
SCIPexprChgMonomialCoef
void SCIPexprChgMonomialCoef(SCIP_EXPRDATA_MONOMIAL *monomial, SCIP_Real newcoef)
Definition: expr.c:6851
SCIPexprgraphGetSumTrees
SCIP_RETCODE SCIPexprgraphGetSumTrees(SCIP_EXPRGRAPH *exprgraph, SCIP_EXPRGRAPHNODE *node, int exprtreessize, int *nexprtrees, SCIP_EXPRTREE **exprtrees, SCIP_Real *exprtreecoefs)
Definition: expr.c:16765
SCIPexprPrint
void SCIPexprPrint(SCIP_EXPR *expr, SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char **varnames, const char **paramnames, SCIP_Real *paramvals)
Definition: expr.c:8225
SCIPexprgraphCreateNodeQuadratic
SCIP_RETCODE SCIPexprgraphCreateNodeQuadratic(BMS_BLKMEM *blkmem, SCIP_EXPRGRAPHNODE **node, int nchildren, SCIP_Real *lincoefs, int nquadelems, SCIP_QUADELEM *quadelems, SCIP_Real constant)
Definition: expr.c:13460
SCIPexprgraphGetSumTreesNSummands
int SCIPexprgraphGetSumTreesNSummands(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:16729
SCIPexprAreMonomialsEqual
SCIP_Bool SCIPexprAreMonomialsEqual(SCIP_EXPRDATA_MONOMIAL *monomial1, SCIP_EXPRDATA_MONOMIAL *monomial2, SCIP_Real eps)
Definition: expr.c:6820
struct_expr.h
data definitions for expressions and expression trees
SCIPexprgraphGetNodeQuadraticNQuadElements
int SCIPexprgraphGetNodeQuadraticNQuadElements(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:13166
SCIPexprGetMonomialExponents
SCIP_Real * SCIPexprGetMonomialExponents(SCIP_EXPRDATA_MONOMIAL *monomial)
Definition: expr.c:5930
SCIPexprReindexVars
void SCIPexprReindexVars(SCIP_EXPR *expr, int *newindices)
Definition: expr.c:8183
SCIPexprtreeGetNVars
int SCIPexprtreeGetNVars(SCIP_EXPRTREE *tree)
Definition: expr.c:8612
SCIPexprgraphFree
SCIP_RETCODE SCIPexprgraphFree(SCIP_EXPRGRAPH **exprgraph)
Definition: expr.c:15124
SCIPexprgraphSetVarNodeUb
void SCIPexprgraphSetVarNodeUb(SCIP_EXPRGRAPH *exprgraph, SCIP_EXPRGRAPHNODE *varnode, SCIP_Real ub)
Definition: expr.c:15057
SCIPexprSubstituteVars
SCIP_RETCODE SCIPexprSubstituteVars(BMS_BLKMEM *blkmem, SCIP_EXPR *expr, SCIP_EXPR **substexprs)
Definition: expr.c:8145
SCIPexprgraphCreateNodePolynomial
SCIP_RETCODE SCIPexprgraphCreateNodePolynomial(BMS_BLKMEM *blkmem, SCIP_EXPRGRAPHNODE **node, int nmonomials, SCIP_EXPRDATA_MONOMIAL **monomials, SCIP_Real constant, SCIP_Bool copymonomials)
Definition: expr.c:13486
SCIPexprgraphUpdateNodeBoundsCurvature
SCIP_RETCODE SCIPexprgraphUpdateNodeBoundsCurvature(SCIP_EXPRGRAPHNODE *node, SCIP_Real infinity, SCIP_Real minstrength, SCIP_Bool clearreverseprop)
Definition: expr.c:14762
SCIPexprgraphGetVarNodes
SCIP_EXPRGRAPHNODE ** SCIPexprgraphGetVarNodes(SCIP_EXPRGRAPH *exprgraph)
Definition: expr.c:14963
SCIP_Messagehdlr
Definition: struct_message.h:36
SCIPexprgraphFreeNode
void SCIPexprgraphFreeNode(BMS_BLKMEM *blkmem, SCIP_EXPRGRAPHNODE **node)
Definition: expr.c:14522
SCIPexprgraphGetSeparableTrees
SCIP_RETCODE SCIPexprgraphGetSeparableTrees(SCIP_EXPRGRAPH *exprgraph, SCIP_EXPRGRAPHNODE *node, int exprtreessize, int *nexprtrees, SCIP_EXPRTREE **exprtrees, SCIP_Real *exprtreecoefs)
Definition: expr.c:16279
SCIP_RETCODE
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
SCIPexprEvalIntShallow
SCIP_RETCODE SCIPexprEvalIntShallow(SCIP_EXPR *expr, SCIP_Real infinity, SCIP_INTERVAL *argvals, SCIP_INTERVAL *varvals, SCIP_Real *param, SCIP_INTERVAL *val)
Definition: expr.c:7907
SCIPexprAddMonomialFactors
SCIP_RETCODE SCIPexprAddMonomialFactors(BMS_BLKMEM *blkmem, SCIP_EXPRDATA_MONOMIAL *monomial, int nfactors, int *childidxs, SCIP_Real *exponents)
Definition: expr.c:6862
SCIPexprGetSignPowerExponent
SCIP_Real SCIPexprGetSignPowerExponent(SCIP_EXPR *expr)
Definition: expr.c:5778
SCIPexprgraphGetNodeVar
void * SCIPexprgraphGetNodeVar(SCIP_EXPRGRAPH *exprgraph, SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:13059
SCIPexprCopyDeep
SCIP_RETCODE SCIPexprCopyDeep(BMS_BLKMEM *blkmem, SCIP_EXPR **targetexpr, SCIP_EXPR *sourceexpr)
Definition: expr.c:6141
SCIP_DECL_USEREXPRINTEVAL
#define SCIP_DECL_USEREXPRINTEVAL(x)
Definition: type_expr.h:261
SCIPexprgraphGetNodeCurvature
SCIP_EXPRCURV SCIPexprgraphGetNodeCurvature(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:13341
SCIPexprGetOpData
void * SCIPexprGetOpData(SCIP_EXPR *expr)
Definition: expr.c:5745
SCIPexprgraphNodePolynomialAddMonomials
SCIP_RETCODE SCIPexprgraphNodePolynomialAddMonomials(BMS_BLKMEM *blkmem, SCIP_EXPRGRAPHNODE *node, int nmonomials, SCIP_EXPRDATA_MONOMIAL **monomials, SCIP_Bool copymonomials)
Definition: expr.c:13511
SCIP_QuadElement
Definition: type_expr.h:100
SCIPexprHasParam
SCIP_Bool SCIPexprHasParam(SCIP_EXPR *expr)
Definition: expr.c:7213
SCIPexprtreeGetInterpreterData
SCIP_EXPRINTDATA * SCIPexprtreeGetInterpreterData(SCIP_EXPRTREE *tree)
Definition: expr.c:8657
SCIPexprGetNMonomials
int SCIPexprGetNMonomials(SCIP_EXPR *expr)
Definition: expr.c:5876
SCIPexprgraphAddExprtreeSum
SCIP_RETCODE SCIPexprgraphAddExprtreeSum(SCIP_EXPRGRAPH *exprgraph, int nexprtrees, SCIP_EXPRTREE **exprtrees, SCIP_Real *coefs, SCIP_EXPRGRAPHNODE **rootnode, SCIP_Bool *rootnodeisnew)
Definition: expr.c:15377
SCIPexprSimplify
SCIP_RETCODE SCIPexprSimplify(BMS_BLKMEM *blkmem, SCIP_MESSAGEHDLR *messagehdlr, SCIP_EXPR *expr, SCIP_Real eps, int maxexpansionexponent, int nvars, int *nlinvars, int *linidxs, SCIP_Real *lincoefs)
Definition: expr.c:7795
SCIPexprgraphAreAllNodeChildrenVars
SCIP_Bool SCIPexprgraphAreAllNodeChildrenVars(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:14631
SCIPexprgraphSetVarNodeBounds
void SCIPexprgraphSetVarNodeBounds(SCIP_EXPRGRAPH *exprgraph, SCIP_EXPRGRAPHNODE *varnode, SCIP_INTERVAL varbounds)
Definition: expr.c:15017
SCIP_EXPRINTCAPABILITY
unsigned int SCIP_EXPRINTCAPABILITY
Definition: type_exprinterpret.h:33
SCIPexprCreatePolynomial
SCIP_RETCODE SCIPexprCreatePolynomial(BMS_BLKMEM *blkmem, SCIP_EXPR **expr, int nchildren, SCIP_EXPR **children, int nmonomials, SCIP_EXPRDATA_MONOMIAL **monomials, SCIP_Real constant, SCIP_Bool copymonomials)
Definition: expr.c:6632
SCIPexprgraphGetNodeDepth
int SCIPexprgraphGetNodeDepth(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:13007
SCIPexprGetNQuadElements
int SCIPexprGetNQuadElements(SCIP_EXPR *expr)
Definition: expr.c:5852
SCIPexprgraphGetVarsBounds
SCIP_INTERVAL * SCIPexprgraphGetVarsBounds(SCIP_EXPRGRAPH *exprgraph)
Definition: expr.c:15077
SCIPexprGetChildren
SCIP_EXPR ** SCIPexprGetChildren(SCIP_EXPR *expr)
Definition: expr.c:5713
eps
real eps
Definition: nlpi_filtersqp.c:238
SCIPexprtreeGetMaxDegree
SCIP_RETCODE SCIPexprtreeGetMaxDegree(SCIP_EXPRTREE *tree, int *maxdegree)
Definition: expr.c:8710
SCIPexprcurvMonomial
SCIP_EXPRCURV SCIPexprcurvMonomial(int nfactors, SCIP_Real *exponents, int *factoridxs, SCIP_EXPRCURV *factorcurv, SCIP_INTERVAL *factorbounds)
Definition: expr.c:361
SCIPexprcurvMultiply
SCIP_EXPRCURV SCIPexprcurvMultiply(SCIP_Real factor, SCIP_EXPRCURV curvature)
Definition: expr.c:240
SCIPexprParse
SCIP_RETCODE SCIPexprParse(BMS_BLKMEM *blkmem, SCIP_MESSAGEHDLR *messagehdlr, SCIP_EXPR **expr, const char *str, const char *lastchar, int *nvars, int *varnames, int varnameslength)
Definition: expr.c:8538
SCIPexprgraphHasNodeNonlinearAncestor
SCIP_Bool SCIPexprgraphHasNodeNonlinearAncestor(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:14647
SCIPexprSortQuadElems
void SCIPexprSortQuadElems(SCIP_EXPR *expr)
Definition: expr.c:6620
SCIPexprgraphGetNodeParents
SCIP_EXPRGRAPHNODE ** SCIPexprgraphGetNodeParents(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:12997
SCIPexprEvalInt
SCIP_RETCODE SCIPexprEvalInt(SCIP_EXPR *expr, SCIP_Real infinity, SCIP_INTERVAL *varvals, SCIP_Real *param, SCIP_INTERVAL *val)
Definition: expr.c:7927
SCIP_DECL_EXPRGRAPHVARADDED
#define SCIP_DECL_EXPRGRAPHVARADDED(x)
Definition: type_expr.h:183
SCIPexprEval
SCIP_RETCODE SCIPexprEval(SCIP_EXPR *expr, SCIP_Real *varvals, SCIP_Real *param, SCIP_Real *val)
Definition: expr.c:7866
SCIPexprSortMonomialFactors
void SCIPexprSortMonomialFactors(SCIP_EXPRDATA_MONOMIAL *monomial)
Definition: expr.c:7116
SCIPexprGetMonomialChildIndices
int * SCIPexprGetMonomialChildIndices(SCIP_EXPRDATA_MONOMIAL *monomial)
Definition: expr.c:5920
SCIPexprtreeFree
SCIP_RETCODE SCIPexprtreeFree(SCIP_EXPRTREE **tree)
Definition: expr.c:8852
SCIPexprgraphPrintDot
SCIP_RETCODE SCIPexprgraphPrintDot(SCIP_EXPRGRAPH *exprgraph, SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char **varnames)
Definition: expr.c:15766
SCIPexprGetQuadConstant
SCIP_Real SCIPexprGetQuadConstant(SCIP_EXPR *expr)
Definition: expr.c:5827
SCIPexprAreEqual
SCIP_Bool SCIPexprAreEqual(SCIP_EXPR *expr1, SCIP_EXPR *expr2, SCIP_Real eps)
Definition: expr.c:7580
SCIP_EXPROP
enum SCIP_ExprOp SCIP_EXPROP
Definition: type_expr.h:91
SCIPexpropGetNChildren
int SCIPexpropGetNChildren(SCIP_EXPROP op)
Definition: expr.c:3273
intervalarith.h
interval arithmetics for provable bounds
SCIPexprtreeGetRoot
SCIP_EXPR * SCIPexprtreeGetRoot(SCIP_EXPRTREE *tree)
Definition: expr.c:8602
SCIPexprPolynomialPower
SCIP_RETCODE SCIPexprPolynomialPower(BMS_BLKMEM *blkmem, SCIP_EXPR *expr, int exponent)
Definition: expr.c:6785
SCIPexprAddToLinear
SCIP_RETCODE SCIPexprAddToLinear(BMS_BLKMEM *blkmem, SCIP_EXPR *expr, int nchildren, SCIP_Real *coefs, SCIP_EXPR **children, SCIP_Real constant)
Definition: expr.c:6539
SCIPexprtreeFreeInterpreterData
SCIP_RETCODE SCIPexprtreeFreeInterpreterData(SCIP_EXPRTREE *tree)
Definition: expr.c:8680
SCIPexprgraphEval
SCIP_RETCODE SCIPexprgraphEval(SCIP_EXPRGRAPH *exprgraph, SCIP_Real *varvals)
Definition: expr.c:15815
SCIPexprgraphCreateNodeUser
SCIP_RETCODE SCIPexprgraphCreateNodeUser(BMS_BLKMEM *blkmem, SCIP_EXPRGRAPHNODE **node, SCIP_USEREXPRDATA *data, SCIP_EXPRINTCAPABILITY evalcapability, SCIP_DECL_USEREXPREVAL((*eval)), SCIP_DECL_USEREXPRINTEVAL((*inteval)), SCIP_DECL_USEREXPRCURV((*curv)), SCIP_DECL_USEREXPRPROP((*prop)), SCIP_DECL_USEREXPRESTIMATE((*estimate)), SCIP_DECL_USEREXPRCOPYDATA((*copydata)), SCIP_DECL_USEREXPRFREEDATA((*freedata)), SCIP_DECL_USEREXPRPRINT((*print)))
Definition: expr.c:13530
SCIPexprgraphMoveNodeParents
SCIP_RETCODE SCIPexprgraphMoveNodeParents(SCIP_EXPRGRAPH *exprgraph, SCIP_EXPRGRAPHNODE **srcnode, SCIP_EXPRGRAPHNODE *targetnode)
Definition: expr.c:14396
SCIPexprMergeMonomials
void SCIPexprMergeMonomials(BMS_BLKMEM *blkmem, SCIP_EXPR *expr, SCIP_Real eps, SCIP_Bool mergefactors)
Definition: expr.c:6805
SCIPexprgraphGetNodeRealPowerExponent
SCIP_Real SCIPexprgraphGetNodeRealPowerExponent(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:13074
SCIPexprgraphGetNodePosition
int SCIPexprgraphGetNodePosition(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:13017
polyscip::global::print
void print(const Container &container, const std::string &prefix="", const std::string &suffix="", std::ostream &os=std::cout, bool negate=false, int prec=6)
Definition: global_functions.h:95
SCIPexprtreeEvalInt
SCIP_RETCODE SCIPexprtreeEvalInt(SCIP_EXPRTREE *tree, SCIP_Real infinity, SCIP_INTERVAL *varvals, SCIP_INTERVAL *val)
Definition: expr.c:8739
SCIPexprgraphCreateNodeLinear
SCIP_RETCODE SCIPexprgraphCreateNodeLinear(BMS_BLKMEM *blkmem, SCIP_EXPRGRAPHNODE **node, int ncoefs, SCIP_Real *coefs, SCIP_Real constant)
Definition: expr.c:13434
SCIPexprgraphGetNodeOperator
SCIP_EXPROP SCIPexprgraphGetNodeOperator(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:13027
SCIPexprgraphAddNode
SCIP_RETCODE SCIPexprgraphAddNode(SCIP_EXPRGRAPH *exprgraph, SCIP_EXPRGRAPHNODE *node, int mindepth, int nchildren, SCIP_EXPRGRAPHNODE **children)
Definition: expr.c:15173
SCIPexprEvalUser
SCIP_RETCODE SCIPexprEvalUser(SCIP_EXPR *expr, SCIP_Real *argvals, SCIP_Real *val, SCIP_Real *gradient, SCIP_Real *hessian)
Definition: expr.c:7969
SCIPexprGetMonomials
SCIP_EXPRDATA_MONOMIAL ** SCIPexprGetMonomials(SCIP_EXPR *expr)
Definition: expr.c:5864
SCIPexprgraphEnableNode
void SCIPexprgraphEnableNode(SCIP_EXPRGRAPH *exprgraph, SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:14547
SCIPexprMultiplyPolynomialByConstant
void SCIPexprMultiplyPolynomialByConstant(BMS_BLKMEM *blkmem, SCIP_EXPR *expr, SCIP_Real factor)
Definition: expr.c:6702
SCIPexprgraphCheckCurvature
SCIP_RETCODE SCIPexprgraphCheckCurvature(SCIP_EXPRGRAPH *exprgraph, SCIP_Real infinity, SCIP_Bool clearreverseprop)
Definition: expr.c:15922
SCIPexprEvalShallow
SCIP_RETCODE SCIPexprEvalShallow(SCIP_EXPR *expr, SCIP_Real *argvals, SCIP_Real *varvals, SCIP_Real *param, SCIP_Real *val)
Definition: expr.c:7847
SCIP_DECL_USEREXPRCURV
#define SCIP_DECL_USEREXPRCURV(x)
Definition: type_expr.h:272
SCIPexpropGetName
const char * SCIPexpropGetName(SCIP_EXPROP op)
Definition: expr.c:3263
SCIPexprChgPolynomialConstant
void SCIPexprChgPolynomialConstant(SCIP_EXPR *expr, SCIP_Real constant)
Definition: expr.c:6689
SCIPexprGetMaxDegree
SCIP_RETCODE SCIPexprGetMaxDegree(SCIP_EXPR *expr, int *maxdegree)
Definition: expr.c:7232
SCIPexprGetOpReal
SCIP_Real SCIPexprGetOpReal(SCIP_EXPR *expr)
Definition: expr.c:5734
SCIPexprtreeHasParam
SCIP_Bool SCIPexprtreeHasParam(SCIP_EXPRTREE *tree)
Definition: expr.c:8694
SCIPexprFreeShallow
void SCIPexprFreeShallow(BMS_BLKMEM *blkmem, SCIP_EXPR **expr)
Definition: expr.c:6221
SCIPexprEvalIntUser
SCIP_RETCODE SCIPexprEvalIntUser(SCIP_EXPR *expr, SCIP_Real infinity, SCIP_INTERVAL *argvals, SCIP_INTERVAL *val, SCIP_INTERVAL *gradient, SCIP_INTERVAL *hessian)
Definition: expr.c:7992
SCIPexprgraphGetNVars
int SCIPexprgraphGetNVars(SCIP_EXPRGRAPH *exprgraph)
Definition: expr.c:14943
SCIPexprCreateUser
SCIP_RETCODE SCIPexprCreateUser(BMS_BLKMEM *blkmem, SCIP_EXPR **expr, int nchildren, SCIP_EXPR **children, SCIP_USEREXPRDATA *data, SCIP_EXPRINTCAPABILITY evalcapability, SCIP_DECL_USEREXPREVAL((*eval)), SCIP_DECL_USEREXPRINTEVAL((*inteval)), SCIP_DECL_USEREXPRCURV((*curv)), SCIP_DECL_USEREXPRPROP((*prop)), SCIP_DECL_USEREXPRESTIMATE((*estimate)), SCIP_DECL_USEREXPRCOPYDATA((*copydata)), SCIP_DECL_USEREXPRFREEDATA((*freedata)), SCIP_DECL_USEREXPRPRINT((*print)))
Definition: expr.c:7153
SCIP_DECL_USEREXPRESTIMATE
#define SCIP_DECL_USEREXPRESTIMATE(x)
Definition: type_expr.h:236
SCIP_DECL_USEREXPRPROP
#define SCIP_DECL_USEREXPRPROP(x)
Definition: type_expr.h:284
SCIPexprGetRealPowerExponent
SCIP_Real SCIPexprGetRealPowerExponent(SCIP_EXPR *expr)
Definition: expr.c:5756
SCIP_Expr
Definition: struct_expr.h:46
SCIPexprcurvPower
SCIP_EXPRCURV SCIPexprcurvPower(SCIP_INTERVAL basebounds, SCIP_EXPRCURV basecurv, SCIP_Real exponent)
Definition: expr.c:253
SCIPexprEstimateUser
SCIP_RETCODE SCIPexprEstimateUser(SCIP_EXPR *expr, SCIP_Real infinity, SCIP_Real *argvals, SCIP_INTERVAL *argbounds, SCIP_Bool overestimate, SCIP_Real *coeffs, SCIP_Real *constant, SCIP_Bool *success)
Definition: expr.c:8107
SCIPexprGetMonomialNFactors
int SCIPexprGetMonomialNFactors(SCIP_EXPRDATA_MONOMIAL *monomial)
Definition: expr.c:5910
SCIP_NlpiOracle::varnames
char ** varnames
Definition: nlpioracle.c:67
SCIP_Bool
#define SCIP_Bool
Definition: def.h:62
SCIPquadelemSortedFind
SCIP_Bool SCIPquadelemSortedFind(SCIP_QUADELEM *quadelems, int idx1, int idx2, int nquadelems, int *pos)
Definition: expr.c:9236
SCIPexprFreeDeep
void SCIPexprFreeDeep(BMS_BLKMEM *blkmem, SCIP_EXPR **expr)
Definition: expr.c:6183
SCIPexprcurvAdd
SCIP_EXPRCURV SCIPexprcurvAdd(SCIP_EXPRCURV curv1, SCIP_EXPRCURV curv2)
Definition: expr.c:205
SCIPexprGetOpIndex
int SCIPexprGetOpIndex(SCIP_EXPR *expr)
Definition: expr.c:5723
SCIPexprgraphGetNodeOperatorIndex
int SCIPexprgraphGetNodeOperatorIndex(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:13037
SCIPexprMultiplyMonomialByMonomial
SCIP_RETCODE SCIPexprMultiplyMonomialByMonomial(BMS_BLKMEM *blkmem, SCIP_EXPRDATA_MONOMIAL *monomial, SCIP_EXPRDATA_MONOMIAL *factor, int *childmap)
Definition: expr.c:6891
SCIPexprtreeSubstituteVars
SCIP_RETCODE SCIPexprtreeSubstituteVars(SCIP_EXPRTREE *tree, SCIP_EXPR **substexprs)
Definition: expr.c:9045
SCIPexprgraphTightenNodeBounds
void SCIPexprgraphTightenNodeBounds(SCIP_EXPRGRAPH *exprgraph, SCIP_EXPRGRAPHNODE *node, SCIP_INTERVAL nodebounds, SCIP_Real minstrength, SCIP_Real infinity, SCIP_Bool *cutoff)
Definition: expr.c:14700
SCIPexprGetPolynomialConstant
SCIP_Real SCIPexprGetPolynomialConstant(SCIP_EXPR *expr)
Definition: expr.c:5888
SCIPexprGetUserData
SCIP_USEREXPRDATA * SCIPexprGetUserData(SCIP_EXPR *expr)
Definition: expr.c:5940
SCIP_ExprGraphNode
Definition: struct_expr.h:116
SCIPexprHasUserEstimator
SCIP_Bool SCIPexprHasUserEstimator(SCIP_EXPR *expr)
Definition: expr.c:5951
SCIPexprgraphSetVarBounds
void SCIPexprgraphSetVarBounds(SCIP_EXPRGRAPH *exprgraph, void *var, SCIP_INTERVAL varbounds)
Definition: expr.c:14997
SCIPexprtreeGetParamVals
SCIP_Real * SCIPexprtreeGetParamVals(SCIP_EXPRTREE *tree)
Definition: expr.c:8632
SCIPexprgraphGetNNodes
int * SCIPexprgraphGetNNodes(SCIP_EXPRGRAPH *exprgraph)
Definition: expr.c:14923
SCIPexprgraphReleaseNode
SCIP_RETCODE SCIPexprgraphReleaseNode(SCIP_EXPRGRAPH *exprgraph, SCIP_EXPRGRAPHNODE **node)
Definition: expr.c:14428
SCIPexprgraphGetNodeSignPowerExponent
SCIP_Real SCIPexprgraphGetNodeSignPowerExponent(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:13096
SCIP_ExprData_Monomial
Definition: struct_expr.h:89
SCIPexprgraphSimplify
SCIP_RETCODE SCIPexprgraphSimplify(SCIP_EXPRGRAPH *exprgraph, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Real eps, int maxexpansionexponent, SCIP_Bool *havechange, SCIP_Bool *domainerror)
Definition: expr.c:15965
SCIPexprMultiplyPolynomialByMonomial
SCIP_RETCODE SCIPexprMultiplyPolynomialByMonomial(BMS_BLKMEM *blkmem, SCIP_EXPR *expr, SCIP_EXPRDATA_MONOMIAL *factor, int *childmap)
Definition: expr.c:6716
SCIPexprgraphGetTree
SCIP_RETCODE SCIPexprgraphGetTree(SCIP_EXPRGRAPH *exprgraph, SCIP_EXPRGRAPHNODE *rootnode, SCIP_EXPRTREE **exprtree)
Definition: expr.c:16226
SCIPexprgraphSetVarNodeValue
void SCIPexprgraphSetVarNodeValue(SCIP_EXPRGRAPHNODE *varnode, SCIP_Real value)
Definition: expr.c:14973
SCIPexprtreeCheckCurvature
SCIP_RETCODE SCIPexprtreeCheckCurvature(SCIP_EXPRTREE *tree, SCIP_Real infinity, SCIP_INTERVAL *varbounds, SCIP_EXPRCURV *curv, SCIP_INTERVAL *bounds)
Definition: expr.c:9010
SCIPexprtreeCopy
SCIP_RETCODE SCIPexprtreeCopy(BMS_BLKMEM *blkmem, SCIP_EXPRTREE **targettree, SCIP_EXPRTREE *sourcetree)
Definition: expr.c:8812
SCIPexprcurvGetName
const char * SCIPexprcurvGetName(SCIP_EXPRCURV curv)
Definition: expr.c:474
SCIPexprgraphGetNodeNChildren
int SCIPexprgraphGetNodeNChildren(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:12967
SCIPexprgraphGetNodeLinearCoefs
SCIP_Real * SCIPexprgraphGetNodeLinearCoefs(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:13107
SCIP_DECL_EXPRGRAPHVARREMOVE
#define SCIP_DECL_EXPRGRAPHVARREMOVE(x)
Definition: type_expr.h:193
SCIPexprCreate
SCIP_RETCODE SCIPexprCreate(BMS_BLKMEM *blkmem, SCIP_EXPR **expr, SCIP_EXPROP op,...)
Definition: expr.c:5973
SCIPexprgraphPropagateVarBounds
SCIP_RETCODE SCIPexprgraphPropagateVarBounds(SCIP_EXPRGRAPH *exprgraph, SCIP_Real infinity, SCIP_Bool clearreverseprop, SCIP_Bool *domainerror)
Definition: expr.c:15836
SCIP_EXPRCURV
enum SCIP_ExprCurv SCIP_EXPRCURV
Definition: type_expr.h:95
SCIPexprgraphHasNodeSibling
SCIP_Bool SCIPexprgraphHasNodeSibling(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:14612
SCIPexprgraphHasNodeUserEstimator
SCIP_Bool SCIPexprgraphHasNodeUserEstimator(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:13309
SCIPexprgraphSetVarNodeLb
void SCIPexprgraphSetVarNodeLb(SCIP_EXPRGRAPH *exprgraph, SCIP_EXPRGRAPHNODE *varnode, SCIP_Real lb)
Definition: expr.c:15037
SCIPexprAddMonomials
SCIP_RETCODE SCIPexprAddMonomials(BMS_BLKMEM *blkmem, SCIP_EXPR *expr, int nmonomials, SCIP_EXPRDATA_MONOMIAL **monomials, SCIP_Bool copymonomials)
Definition: expr.c:6667
SCIPexprgraphGetNodeUserData
SCIP_USEREXPRDATA * SCIPexprgraphGetNodeUserData(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:13297
SCIPexprtreeGetNParams
int SCIPexprtreeGetNParams(SCIP_EXPRTREE *tree)
Definition: expr.c:8622
SCIPexprgraphFindVarNode
SCIP_Bool SCIPexprgraphFindVarNode(SCIP_EXPRGRAPH *exprgraph, void *var, SCIP_EXPRGRAPHNODE **varnode)
Definition: expr.c:15689
SCIPexprgraphGetDepth
int SCIPexprgraphGetDepth(SCIP_EXPRGRAPH *exprgraph)
Definition: expr.c:14913
SCIPexprtreeSimplify
SCIP_RETCODE SCIPexprtreeSimplify(SCIP_EXPRTREE *tree, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Real eps, int maxexpansionexponent, int *nlinvars, int *linidxs, SCIP_Real *lincoefs)
Definition: expr.c:8926
SCIPexprgraphGetNodeOperatorReal
SCIP_Real SCIPexprgraphGetNodeOperatorReal(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:13048
SCIPexprgraphGetNodePolynomialConstant
SCIP_Real SCIPexprgraphGetNodePolynomialConstant(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:13202
SCIPexprgraphCaptureNode
void SCIPexprgraphCaptureNode(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:12945
SCIPexprgraphFindConstNode
SCIP_Bool SCIPexprgraphFindConstNode(SCIP_EXPRGRAPH *exprgraph, SCIP_Real constant, SCIP_EXPRGRAPHNODE **constnode)
Definition: expr.c:15718
SCIPexprMulConstant
SCIP_RETCODE SCIPexprMulConstant(BMS_BLKMEM *blkmem, SCIP_EXPR **expr, SCIP_EXPR *term, SCIP_Real factor)
Definition: expr.c:6404
type_expr.h
type definitions for expressions and expression trees
SCIPexprgraphPrintNode
void SCIPexprgraphPrintNode(SCIP_EXPRGRAPHNODE *node, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
Definition: expr.c:14684
pub_message.h
public methods for message output
SCIPquadelemSort
void SCIPquadelemSort(SCIP_QUADELEM *quadelems, int nquadelems)
Definition: expr.c:9211
SCIPexprgraphCreateNode
SCIP_RETCODE SCIPexprgraphCreateNode(BMS_BLKMEM *blkmem, SCIP_EXPRGRAPHNODE **node, SCIP_EXPROP op,...)
Definition: expr.c:13351
SCIPexprReindexParams
void SCIPexprReindexParams(SCIP_EXPR *expr, int *newindices)
Definition: expr.c:8204
SCIPexprGetOperator
SCIP_EXPROP SCIPexprGetOperator(SCIP_EXPR *expr)
Definition: expr.c:5693
SCIP_DECL_USEREXPRCOPYDATA
#define SCIP_DECL_USEREXPRCOPYDATA(x)
Definition: type_expr.h:293
SCIP_Real
#define SCIP_Real
Definition: def.h:150
SCIPexprGetIntPowerExponent
int SCIPexprGetIntPowerExponent(SCIP_EXPR *expr)
Definition: expr.c:5767
SCIPexprgraphReplaceVarByLinearSum
SCIP_RETCODE SCIPexprgraphReplaceVarByLinearSum(SCIP_EXPRGRAPH *exprgraph, void *var, int ncoefs, SCIP_Real *coefs, void **vars, SCIP_Real constant)
Definition: expr.c:15517
SCIPexprGetVarsUsage
void SCIPexprGetVarsUsage(SCIP_EXPR *expr, int *varsusage)
Definition: expr.c:7557
SCIPexprgraphPropagateNodeBounds
void SCIPexprgraphPropagateNodeBounds(SCIP_EXPRGRAPH *exprgraph, SCIP_Real infinity, SCIP_Real minstrength, SCIP_Bool *cutoff)
Definition: expr.c:15890
SCIPexprGetLinearConstant
SCIP_Real SCIPexprGetLinearConstant(SCIP_EXPR *expr)
Definition: expr.c:5802
SCIPexprgraphGetNodes
SCIP_EXPRGRAPHNODE *** SCIPexprgraphGetNodes(SCIP_EXPRGRAPH *exprgraph)
Definition: expr.c:14933
SCIPexprtreeCreate
SCIP_RETCODE SCIPexprtreeCreate(BMS_BLKMEM *blkmem, SCIP_EXPRTREE **tree, SCIP_EXPR *root, int nvars, int nparams, SCIP_Real *params)
Definition: expr.c:8771
SCIPexprMonomialPower
void SCIPexprMonomialPower(SCIP_EXPRDATA_MONOMIAL *monomial, int exponent)
Definition: expr.c:6926
SCIPexprgraphGetNodePolynomialMonomials
SCIP_EXPRDATA_MONOMIAL ** SCIPexprgraphGetNodePolynomialMonomials(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:13178
SCIP_ExprGraph
Definition: struct_expr.h:155
SCIPexprgraphGetNodeChildren
SCIP_EXPRGRAPHNODE ** SCIPexprgraphGetNodeChildren(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:12977
SCIPexprtreeSetParamVal
void SCIPexprtreeSetParamVal(SCIP_EXPRTREE *tree, int paramidx, SCIP_Real paramval)
Definition: expr.c:8642
SCIP_NlpiOracle::blkmem
BMS_BLKMEM * blkmem
Definition: nlpioracle.c:59
SCIPexprCreateMonomial
SCIP_RETCODE SCIPexprCreateMonomial(BMS_BLKMEM *blkmem, SCIP_EXPRDATA_MONOMIAL **monomial, SCIP_Real coef, int nfactors, int *childidxs, SCIP_Real *exponents)
Definition: expr.c:7035
SCIPexprGetLinearCoefs
SCIP_Real * SCIPexprGetLinearCoefs(SCIP_EXPR *expr)
Definition: expr.c:5789
SCIPexprFindMonomialFactor
SCIP_Bool SCIPexprFindMonomialFactor(SCIP_EXPRDATA_MONOMIAL *monomial, int childidx, int *pos)
Definition: expr.c:7136
SCIP_ExprTree
Definition: struct_expr.h:55
SCIPexprgraphGetNodeQuadraticLinearCoefs
SCIP_Real * SCIPexprgraphGetNodeQuadraticLinearCoefs(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:13142
SCIPexprtreeAddExpr
SCIP_RETCODE SCIPexprtreeAddExpr(SCIP_EXPRTREE *tree, SCIP_EXPR *expr, SCIP_Bool copyexpr)
Definition: expr.c:8981
SCIPexprgraphGetNodeQuadraticConstant
SCIP_Real SCIPexprgraphGetNodeQuadraticConstant(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:13130
def.h
common defines and data types used in all packages of SCIP
BMS_BLKMEM
struct BMS_BlkMem BMS_BLKMEM
Definition: memory.h:419
SCIPexprCheckCurvature
SCIP_RETCODE SCIPexprCheckCurvature(SCIP_EXPR *expr, SCIP_Real infinity, SCIP_INTERVAL *varbounds, SCIP_Real *param, SCIP_EXPRCURV *curv, SCIP_INTERVAL *bounds)
Definition: expr.c:8062
SCIPexprgraphGetSubtreeVarsUsage
void SCIPexprgraphGetSubtreeVarsUsage(SCIP_EXPRGRAPH *exprgraph, SCIP_EXPRGRAPHNODE *node, int *varsusage)
Definition: expr.c:16713
SCIP_EXPRINTDATA
struct SCIP_ExprIntData SCIP_EXPRINTDATA
Definition: type_exprinterpret.h:32
SCIPexprCreateLinear
SCIP_RETCODE SCIPexprCreateLinear(BMS_BLKMEM *blkmem, SCIP_EXPR **expr, int nchildren, SCIP_EXPR **children, SCIP_Real *coefs, SCIP_Real constant)
Definition: expr.c:6502
SCIPexprgraphGetNodeVal
SCIP_Real SCIPexprgraphGetNodeVal(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:13331
SCIP_DECL_USEREXPRFREEDATA
#define SCIP_DECL_USEREXPRFREEDATA(x)
Definition: type_expr.h:301
SCIPexprtreeSetParams
SCIP_RETCODE SCIPexprtreeSetParams(SCIP_EXPRTREE *tree, int nparams, SCIP_Real *paramvals)
Definition: expr.c:8876
SCIPexprgraphAddVars
SCIP_RETCODE SCIPexprgraphAddVars(SCIP_EXPRGRAPH *exprgraph, int nvars, void **vars, SCIP_EXPRGRAPHNODE **varnodes)
Definition: expr.c:15257
SCIPexprgraphIsNodeEnabled
SCIP_Bool SCIPexprgraphIsNodeEnabled(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:12957
SCIPexprSortMonomials
void SCIPexprSortMonomials(SCIP_EXPR *expr)
Definition: expr.c:7023
SCIPexprGetQuadLinearCoefs
SCIP_Real * SCIPexprGetQuadLinearCoefs(SCIP_EXPR *expr)
Definition: expr.c:5840
SCIPexprgraphCreate
SCIP_RETCODE SCIPexprgraphCreate(BMS_BLKMEM *blkmem, SCIP_EXPRGRAPH **exprgraph, int varssizeinit, int depthinit, SCIP_DECL_EXPRGRAPHVARADDED((*exprgraphvaradded)), SCIP_DECL_EXPRGRAPHVARREMOVE((*exprgraphvarremove)), SCIP_DECL_EXPRGRAPHVARCHGIDX((*exprgraphvarchgidx)), void *userdata)
Definition: expr.c:15085
SCIP_DECL_EXPRGRAPHVARCHGIDX
#define SCIP_DECL_EXPRGRAPHVARCHGIDX(x)
Definition: type_expr.h:205
SCIPexprgraphGetNodeBounds
SCIP_INTERVAL SCIPexprgraphGetNodeBounds(SCIP_EXPRGRAPHNODE *node)
Definition: expr.c:13321
memory.h
memory allocation routines